DriverConfigurazioneDB_configDriver.java

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

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

  29. import org.apache.commons.lang.StringUtils;
  30. import org.openspcoop2.core.byok.BYOKUtilities;
  31. import org.openspcoop2.core.byok.IDriverBYOK;
  32. import org.openspcoop2.core.commons.DBUtils;
  33. import org.openspcoop2.core.commons.IExtendedInfo;
  34. import org.openspcoop2.core.config.AccessoConfigurazione;
  35. import org.openspcoop2.core.config.AccessoDatiAttributeAuthority;
  36. import org.openspcoop2.core.config.AccessoDatiAutenticazione;
  37. import org.openspcoop2.core.config.AccessoDatiAutorizzazione;
  38. import org.openspcoop2.core.config.AccessoDatiConsegnaApplicativi;
  39. import org.openspcoop2.core.config.AccessoDatiGestioneToken;
  40. import org.openspcoop2.core.config.AccessoDatiKeystore;
  41. import org.openspcoop2.core.config.AccessoDatiRichieste;
  42. import org.openspcoop2.core.config.AccessoRegistro;
  43. import org.openspcoop2.core.config.AccessoRegistroRegistro;
  44. import org.openspcoop2.core.config.Attachments;
  45. import org.openspcoop2.core.config.Cache;
  46. import org.openspcoop2.core.config.CanaliConfigurazione;
  47. import org.openspcoop2.core.config.Configurazione;
  48. import org.openspcoop2.core.config.ConfigurazioneGeneraleHandler;
  49. import org.openspcoop2.core.config.ConfigurazioneGestioneErrore;
  50. import org.openspcoop2.core.config.ConfigurazioneMessageHandlers;
  51. import org.openspcoop2.core.config.ConfigurazioneMultitenant;
  52. import org.openspcoop2.core.config.ConfigurazioneServiceHandlers;
  53. import org.openspcoop2.core.config.ConfigurazioneTracciamentoPorta;
  54. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  55. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  56. import org.openspcoop2.core.config.CorsConfigurazione;
  57. import org.openspcoop2.core.config.Dump;
  58. import org.openspcoop2.core.config.DumpConfigurazione;
  59. import org.openspcoop2.core.config.GestioneErrore;
  60. import org.openspcoop2.core.config.IdSoggetto;
  61. import org.openspcoop2.core.config.IndirizzoRisposta;
  62. import org.openspcoop2.core.config.InoltroBusteNonRiscontrate;
  63. import org.openspcoop2.core.config.IntegrationManager;
  64. import org.openspcoop2.core.config.MessaggiDiagnostici;
  65. import org.openspcoop2.core.config.OpenspcoopAppender;
  66. import org.openspcoop2.core.config.OpenspcoopSorgenteDati;
  67. import org.openspcoop2.core.config.Property;
  68. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  69. import org.openspcoop2.core.config.ResponseCachingConfigurazioneGenerale;
  70. import org.openspcoop2.core.config.Risposte;
  71. import org.openspcoop2.core.config.RoutingTable;
  72. import org.openspcoop2.core.config.StatoServiziPdd;
  73. import org.openspcoop2.core.config.StatoServiziPddIntegrationManager;
  74. import org.openspcoop2.core.config.StatoServiziPddPortaApplicativa;
  75. import org.openspcoop2.core.config.StatoServiziPddPortaDelegata;
  76. import org.openspcoop2.core.config.SystemProperties;
  77. import org.openspcoop2.core.config.TipoFiltroAbilitazioneServizi;
  78. import org.openspcoop2.core.config.Tracciamento;
  79. import org.openspcoop2.core.config.TracciamentoConfigurazione;
  80. import org.openspcoop2.core.config.TracciamentoConfigurazioneFiletrace;
  81. import org.openspcoop2.core.config.Transazioni;
  82. import org.openspcoop2.core.config.ValidazioneBuste;
  83. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  84. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  85. import org.openspcoop2.core.config.constants.RegistroTipo;
  86. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  87. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  88. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  89. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  90. import org.openspcoop2.core.constants.CostantiDB;
  91. import org.openspcoop2.core.id.IDSoggetto;
  92. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  93. import org.openspcoop2.utils.sql.ISQLQueryObject;
  94. import org.openspcoop2.utils.sql.SQLObjectFactory;

  96. /**
  97.  * DriverConfigurazioneDB_configDriver
  98.  * 
  99.  * 
  100.  * @author Sandra Giangrandi (sandra@link.it)
  101.  * @author Stefano Corallo (corallo@link.it)
  102.  * @author $Author$
  103.  * @version $Rev$, $Date$
  104.  */
  105. public class DriverConfigurazioneDB_configDriver {

  107.     private DriverConfigurazioneDB driver = null;
  108.     private DriverConfigurazioneDB_porteDriver porteDriver = null;
  109.     private DriverConfigurazioneDB_gestioneErroreDriver gestioneErroreDriver = null;
  110.     private DriverConfigurazioneDB_routingTableDriver routingTableDriver = null;
  111.     private DriverConfigurazioneDB_genericPropertiesDriver genericPropertiesDriver = null;
  112.     
  113.     
  114.     protected DriverConfigurazioneDB_configDriver(DriverConfigurazioneDB driver) {
  115.         this.driver = driver;
  116.         this.porteDriver = new DriverConfigurazioneDB_porteDriver(driver);
  117.         this.gestioneErroreDriver = new DriverConfigurazioneDB_gestioneErroreDriver(driver);
  118.         this.routingTableDriver = new DriverConfigurazioneDB_routingTableDriver(driver);
  119.         this.genericPropertiesDriver = new DriverConfigurazioneDB_genericPropertiesDriver(driver);
  120.     }
  121.     
  122.     protected AccessoRegistro getAccessoRegistro() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {

  124.         Connection con = null;
  125.         PreparedStatement stm = null;
  126.         ResultSet rs = null;
  127.         String sqlQuery = "";

  129.         if (this.driver.atomica) {
  130.             try {
  131.                 con = this.driver.getConnectionFromDatasource("getAccessoRegistro");

  133.             } catch (Exception e) {
  134.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoRegistro] Exception accedendo al datasource :" + e.getMessage(),e);

  136.             }

  138.         } else
  139.             con = this.driver.globalConnection;

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

  143.         try {
  144.             AccessoRegistro car = new AccessoRegistro();
  145.             Cache cache = null;

  147.             // aggiungo i registri
  148.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  149.             sqlQueryObject.addFromTable(CostantiDB.REGISTRI);
  150.             sqlQueryObject.addSelectField("*");
  151.             sqlQuery = sqlQueryObject.createSQLQuery();
  152.             stm = con.prepareStatement(sqlQuery);
  153.             rs = stm.executeQuery();

  155.             AccessoRegistroRegistro itemcar = null;

  157.             while (rs.next()) {
  158.                 itemcar = new AccessoRegistroRegistro();

  160.                 // TIPO
  161.                 RegistroTipo tipoReg = CostantiConfigurazione.REGISTRO_XML;
  162.                 String tmpTipo = rs.getString("tipo");
  163.                 if (tmpTipo.equals("uddi"))
  164.                     tipoReg = CostantiConfigurazione.REGISTRO_UDDI;
  165.                 else if (tmpTipo.equals("web"))
  166.                     tipoReg = CostantiConfigurazione.REGISTRO_WEB;
  167.                 else if (tmpTipo.equals("db"))
  168.                     tipoReg = CostantiConfigurazione.REGISTRO_DB;
  169.                 else if (tmpTipo.equals("ws"))
  170.                     tipoReg = CostantiConfigurazione.REGISTRO_WS;

  172.                 itemcar.setTipo(tipoReg);

  174.                 // nome
  175.                 itemcar.setNome(rs.getString("nome"));

  177.                 // location
  178.                 itemcar.setLocation(rs.getString("location"));

  180.                 // USER e PASSWORD
  181.                 String tmpUser = rs.getString("utente");
  182.                 String tmpPw = rs.getString("password");
  183.                 if ((tmpUser != null) && (tmpPw != null) && !tmpUser.equals("") && !tmpPw.equals("")) {
  184.                     itemcar.setUser(tmpUser);
  185.                     itemcar.setPassword(tmpPw);
  186.                 }

  188.                 car.addRegistro(itemcar);
  189.             }
  190.             rs.close();
  191.             stm.close();

  193.             //fix bug 23/11/07
  194.             //se nn trovo registri non va lanciata l'eccezione in quanto
  195.             //possono esistere variabili di configurazione successive che vanno lette
  196.             //se nn ho trovato registri allora lancio eccezione
  197.             //if(itemcar==null) throw new DriverConfigurazioneNotFound("Nessun registro trovato");

  199.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  200.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  201.             sqlQueryObject.addSelectField("*");
  202.             sqlQuery = sqlQueryObject.createSQLQuery();
  203.             stm = con.prepareStatement(sqlQuery);

  205.             this.driver.logDebug("eseguo query : " + sqlQuery);

  207.             rs = stm.executeQuery();

  209.             if (rs.next()) {
  210.                 String tmpCache = rs.getString("statocache");
  211.                 if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  212.                     cache = new Cache();

  214.                     String tmpDim = rs.getString("dimensionecache");
  215.                     if (tmpDim != null && !tmpDim.equals(""))
  216.                         cache.setDimensione(tmpDim);

  218.                     String tmpAlg = rs.getString("algoritmocache");
  219.                     if (tmpAlg.equalsIgnoreCase("LRU"))
  220.                         cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  221.                     else
  222.                         cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  224.                     String tmpIdle = rs.getString("idlecache");
  225.                     String tmpLife = rs.getString("lifecache");

  227.                     if (tmpIdle != null && !tmpIdle.equals(""))
  228.                         cache.setItemIdleTime(tmpIdle);
  229.                     if (tmpLife != null && !tmpLife.equals(""))
  230.                         cache.setItemLifeSecond(tmpLife);

  232.                     car.setCache(cache);

  234.                 }
  235.                 rs.close();
  236.                 stm.close();
  237.             }
  238.             //nel caso in cui non esiste nessuna configurazione non lancio eccezioni
  239.             //perche' possono essere presenti dei registri
  240.             /*else{
  241.                 rs.close();
  242.                 stm.close();
  243.                 throw new DriverConfigurazioneNotFound("Nessuna Configurazione trovata.");
  244.             }*/



  248.             return car;

  250.         } catch (SQLException se) {
  251.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoRegistro] SqlException: " + se.getMessage(),se);
  252.         }catch (Exception se) {
  253.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoRegistro] Exception: " + se.getMessage(),se);
  254.         } finally {
  255.             //Chiudo statement and resultset
  256.             JDBCUtilities.closeResources(rs, stm);
  257.             this.driver.closeConnection(con);
  258.         }
  259.     }

  261.     protected void createAccessoRegistro(AccessoRegistroRegistro registro) throws DriverConfigurazioneException {

  263.         Connection con = null;
  264.         boolean error = false;

  266.         if (this.driver.atomica) {
  267.             try {
  268.                 con = this.driver.getConnectionFromDatasource("createAccessoRegistro");
  269.                 con.setAutoCommit(false);
  270.             } catch (Exception e) {
  271.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoRegistro] Exception accedendo al datasource :" + e.getMessage(),e);

  273.             }

  275.         } else
  276.             con = this.driver.globalConnection;

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

  280.         try {
  281.             this.driver.logDebug("CRUDAccessoRegistro type = 1");
  282.             DriverConfigurazioneDB_configLIB.CRUDAccessoRegistro(1, registro, con);

  284.         } catch (Exception qe) {
  285.             error = true;
  286.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoRegistro] Errore durante la createAccessoRegistro : " + qe.getMessage(),qe);
  287.         } finally {

  289.             this.driver.closeConnection(error,con);
  290.         }
  291.     }

  293.     protected void updateAccessoRegistro(AccessoRegistroRegistro registro) throws DriverConfigurazioneException {
  294.         Connection con = null;
  295.         boolean error = false;

  297.         if (this.driver.atomica) {
  298.             try {
  299.                 con = this.driver.getConnectionFromDatasource("updateAccessoRegistro");
  300.                 con.setAutoCommit(false);
  301.             } catch (Exception e) {
  302.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateAccessoRegistro] Exception accedendo al datasource :" + e.getMessage(),e);

  304.             }

  306.         } else
  307.             con = this.driver.globalConnection;

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

  311.         try {
  312.             this.driver.logDebug("CRUDAccessoRegistro type = 2");
  313.             DriverConfigurazioneDB_configLIB.CRUDAccessoRegistro(2, registro, con);

  315.         } catch (Exception qe) {
  316.             error = true;
  317.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateAccessoRegistro] Errore durante la updateAccessoRegistro : " + qe.getMessage(),qe);
  318.         } finally {

  320.             this.driver.closeConnection(error,con);
  321.         }
  322.     }

  324.     protected void deleteAccessoRegistro(AccessoRegistroRegistro registro) throws DriverConfigurazioneException {
  325.         Connection con = null;
  326.         boolean error = false;

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

  335.             }

  337.         } else
  338.             con = this.driver.globalConnection;

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

  342.         try {
  343.             this.driver.logDebug("CRUDAccessoRegistro type = 3");
  344.             DriverConfigurazioneDB_configLIB.CRUDAccessoRegistro(3, registro, con);

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

  351.             this.driver.closeConnection(error,con);
  352.         }
  353.     }
  354.     
  355.     
  356.     
  357.     
  358.     protected AccessoConfigurazione getAccessoConfigurazione() throws DriverConfigurazioneException {

  360.         Connection con = null;
  361.         PreparedStatement stm = null;
  362.         ResultSet rs = null;
  363.         String sqlQuery = "";

  365.         if (this.driver.atomica) {
  366.             try {
  367.                 con = this.driver.getConnectionFromDatasource("getAccessoConfigurazione");

  369.             } catch (Exception e) {
  370.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoConfigurazione] Exception accedendo al datasource :" + e.getMessage(),e);

  372.             }

  374.         } else
  375.             con = this.driver.globalConnection;

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

  379.         try {
  380.             AccessoConfigurazione accessoConfigurazione = new AccessoConfigurazione();
  381.             Cache cache = null;

  383.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  384.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  385.             sqlQueryObject.addSelectField("*");
  386.             sqlQuery = sqlQueryObject.createSQLQuery();
  387.             stm = con.prepareStatement(sqlQuery);

  389.             this.driver.logDebug("eseguo query : " + sqlQuery);

  391.             rs = stm.executeQuery();

  393.             if (rs.next()) {
  394.                 String tmpCache = rs.getString("config_statocache");
  395.                 if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  396.                     cache = new Cache();

  398.                     String tmpDim = rs.getString("config_dimensionecache");
  399.                     if (tmpDim != null && !tmpDim.equals(""))
  400.                         cache.setDimensione(tmpDim);

  402.                     String tmpAlg = rs.getString("config_algoritmocache");
  403.                     if (tmpAlg.equalsIgnoreCase("LRU"))
  404.                         cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  405.                     else
  406.                         cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  408.                     String tmpIdle = rs.getString("config_idlecache");
  409.                     String tmpLife = rs.getString("config_lifecache");

  411.                     if (tmpIdle != null && !tmpIdle.equals(""))
  412.                         cache.setItemIdleTime(tmpIdle);
  413.                     if (tmpLife != null && !tmpLife.equals(""))
  414.                         cache.setItemLifeSecond(tmpLife);

  416.                     accessoConfigurazione.setCache(cache);

  418.                 }
  419.                 rs.close();
  420.                 stm.close();
  421.             }

  423.             return accessoConfigurazione;

  425.         } catch (SQLException se) {
  426.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoConfigurazione] SqlException: " + se.getMessage(),se);
  427.         }catch (Exception se) {
  428.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoConfigurazione] Exception: " + se.getMessage(),se);
  429.         } finally {
  430.             //Chiudo statement and resultset
  431.             JDBCUtilities.closeResources(rs, stm);
  432.             this.driver.closeConnection(con);
  433.         }
  434.     }

  436.     protected void createAccessoConfigurazione(AccessoConfigurazione accessoConfigurazione) throws DriverConfigurazioneException {

  438.         Connection con = null;
  439.         boolean error = false;

  441.         if (this.driver.atomica) {
  442.             try {
  443.                 con = this.driver.getConnectionFromDatasource("createAccessoConfigurazione");
  444.                 con.setAutoCommit(false);
  445.             } catch (Exception e) {
  446.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoConfigurazione] Exception accedendo al datasource :" + e.getMessage(),e);

  448.             }

  450.         } else
  451.             con = this.driver.globalConnection;

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

  455.         try {
  456.             this.driver.logDebug("CRUDAccessoConfigurazione type = 1");
  457.             DriverConfigurazioneDB_configLIB.CRUDAccessoConfigurazione(1, accessoConfigurazione, con);

  459.         } catch (Exception qe) {
  460.             error = true;
  461.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoConfigurazione] Errore durante la createAccessoConfigurazione : " + qe.getMessage(),qe);
  462.         } finally {

  464.             this.driver.closeConnection(error,con);
  465.         }
  466.     }

  468.     protected void updateAccessoConfigurazione(AccessoConfigurazione accessoConfigurazione) throws DriverConfigurazioneException {
  469.         Connection con = null;
  470.         boolean error = false;

  472.         if (this.driver.atomica) {
  473.             try {
  474.                 con = this.driver.getConnectionFromDatasource("updateAccessoConfigurazione");
  475.                 con.setAutoCommit(false);
  476.             } catch (Exception e) {
  477.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateAccessoConfigurazione] Exception accedendo al datasource :" + e.getMessage(),e);

  479.             }

  481.         } else
  482.             con = this.driver.globalConnection;

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

  486.         try {
  487.             this.driver.logDebug("CRUDAccessoConfigurazione type = 2");
  488.             DriverConfigurazioneDB_configLIB.CRUDAccessoConfigurazione(2, accessoConfigurazione, con);

  490.         } catch (Exception qe) {
  491.             error = true;
  492.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateAccessoConfigurazione] Errore durante la updateAccessoConfigurazione : " + qe.getMessage(),qe);
  493.         } finally {

  495.             this.driver.closeConnection(error,con);
  496.         }
  497.     }

  499.     protected void deleteAccessoConfigurazione(AccessoConfigurazione accessoConfigurazione) throws DriverConfigurazioneException {
  500.         Connection con = null;
  501.         boolean error = false;

  503.         if (this.driver.atomica) {
  504.             try {
  505.                 con = this.driver.getConnectionFromDatasource("deleteAccessoConfigurazione");
  506.                 con.setAutoCommit(false);
  507.             } catch (Exception e) {
  508.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteAccessoConfigurazione] Exception accedendo al datasource :" + e.getMessage(),e);

  510.             }

  512.         } else
  513.             con = this.driver.globalConnection;

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

  517.         try {
  518.             this.driver.logDebug("CRUDAccessoConfigurazione type = 3");
  519.             DriverConfigurazioneDB_configLIB.CRUDAccessoConfigurazione(3, accessoConfigurazione, con);

  521.         } catch (Exception qe) {
  522.             error = true;
  523.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteAccessoConfigurazione] Errore durante la deleteAccessoConfigurazione : " + qe.getMessage(),qe);
  524.         } finally {

  526.             this.driver.closeConnection(error,con);
  527.         }
  528.     }
  529.     
  530.     
  531.     
  532.     
  533.     
  534.     protected AccessoDatiAutorizzazione getAccessoDatiAutorizzazione() throws DriverConfigurazioneException {

  536.         Connection con = null;
  537.         PreparedStatement stm = null;
  538.         ResultSet rs = null;
  539.         String sqlQuery = "";

  541.         if (this.driver.atomica) {
  542.             try {
  543.                 con = this.driver.getConnectionFromDatasource("getAccessoDatiAutorizzazione");

  545.             } catch (Exception e) {
  546.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAutorizzazione] Exception accedendo al datasource :" + e.getMessage(),e);

  548.             }

  550.         } else
  551.             con = this.driver.globalConnection;

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

  555.         try {
  556.             AccessoDatiAutorizzazione accessoDatiAutorizzazione = new AccessoDatiAutorizzazione();
  557.             
  558.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  559.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  560.             sqlQueryObject.addSelectField("*");
  561.             sqlQuery = sqlQueryObject.createSQLQuery();
  562.             stm = con.prepareStatement(sqlQuery);

  564.             this.driver.logDebug("eseguo query : " + sqlQuery);

  566.             rs = stm.executeQuery();

  568.             if (rs.next()) {
  569.                 readAccessoDatiAutorizzazione(rs, accessoDatiAutorizzazione);
  570.                 rs.close();
  571.                 stm.close();
  572.             }

  574.             return accessoDatiAutorizzazione;

  576.         } catch (SQLException se) {
  577.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAutorizzazione] SqlException: " + se.getMessage(),se);
  578.         }catch (Exception se) {
  579.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAutorizzazione] Exception: " + se.getMessage(),se);
  580.         } finally {
  581.             //Chiudo statement and resultset
  582.             JDBCUtilities.closeResources(rs, stm);
  583.             this.driver.closeConnection(con);
  584.         }
  585.     }
  586.     private void readAccessoDatiAutorizzazione(ResultSet rs, AccessoDatiAutorizzazione accessoDatiAutorizzazione) throws SQLException {
  587.         String tmpCache = rs.getString("auth_statocache");
  588.         if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  589.             Cache cache = new Cache();

  591.             String tmpDim = rs.getString("auth_dimensionecache");
  592.             if (tmpDim != null && !tmpDim.equals(""))
  593.                 cache.setDimensione(tmpDim);

  595.             String tmpAlg = rs.getString("auth_algoritmocache");
  596.             if (tmpAlg.equalsIgnoreCase("LRU"))
  597.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  598.             else
  599.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  601.             String tmpIdle = rs.getString("auth_idlecache");
  602.             String tmpLife = rs.getString("auth_lifecache");

  604.             if (tmpIdle != null && !tmpIdle.equals(""))
  605.                 cache.setItemIdleTime(tmpIdle);
  606.             if (tmpLife != null && !tmpLife.equals(""))
  607.                 cache.setItemLifeSecond(tmpLife);

  609.             accessoDatiAutorizzazione.setCache(cache);

  611.         }
  612.     }
  613.     
  614.     
  615.     
  616.     protected AccessoDatiAutenticazione getAccessoDatiAutenticazione() throws DriverConfigurazioneException {

  618.         Connection con = null;
  619.         PreparedStatement stm = null;
  620.         ResultSet rs = null;
  621.         String sqlQuery = "";

  623.         if (this.driver.atomica) {
  624.             try {
  625.                 con = this.driver.getConnectionFromDatasource("getAccessoDatiAutenticazione");

  627.             } catch (Exception e) {
  628.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAutenticazione] Exception accedendo al datasource :" + e.getMessage(),e);

  630.             }

  632.         } else
  633.             con = this.driver.globalConnection;

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

  637.         try {
  638.             AccessoDatiAutenticazione accessoDatiAutenticazione = new AccessoDatiAutenticazione();
  639.             
  640.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  641.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  642.             sqlQueryObject.addSelectField("*");
  643.             sqlQuery = sqlQueryObject.createSQLQuery();
  644.             stm = con.prepareStatement(sqlQuery);

  646.             this.driver.logDebug("eseguo query : " + sqlQuery);

  648.             rs = stm.executeQuery();

  650.             if (rs.next()) {
  651.                 readAccessoDatiAutenticazione(rs, accessoDatiAutenticazione);
  652.                 rs.close();
  653.                 stm.close();
  654.             }

  656.             return accessoDatiAutenticazione;

  658.         } catch (SQLException se) {
  659.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAutenticazione] SqlException: " + se.getMessage(),se);
  660.         }catch (Exception se) {
  661.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAutenticazione] Exception: " + se.getMessage(),se);
  662.         } finally {
  663.             //Chiudo statement and resultset
  664.             JDBCUtilities.closeResources(rs, stm);
  665.             this.driver.closeConnection(con);
  666.         }
  667.     }
  668.     private void readAccessoDatiAutenticazione(ResultSet rs, AccessoDatiAutenticazione accessoDatiAutenticazione) throws SQLException {
  669.         String tmpCache = rs.getString("authn_statocache");
  670.         if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  671.             Cache cache = new Cache();

  673.             String tmpDim = rs.getString("authn_dimensionecache");
  674.             if (tmpDim != null && !tmpDim.equals(""))
  675.                 cache.setDimensione(tmpDim);

  677.             String tmpAlg = rs.getString("authn_algoritmocache");
  678.             if (tmpAlg.equalsIgnoreCase("LRU"))
  679.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  680.             else
  681.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  683.             String tmpIdle = rs.getString("authn_idlecache");
  684.             String tmpLife = rs.getString("authn_lifecache");

  686.             if (tmpIdle != null && !tmpIdle.equals(""))
  687.                 cache.setItemIdleTime(tmpIdle);
  688.             if (tmpLife != null && !tmpLife.equals(""))
  689.                 cache.setItemLifeSecond(tmpLife);

  691.             accessoDatiAutenticazione.setCache(cache);

  693.         }
  694.     }
  695.     
  696.     
  697.     protected AccessoDatiGestioneToken getAccessoDatiGestioneToken() throws DriverConfigurazioneException {

  699.         Connection con = null;
  700.         PreparedStatement stm = null;
  701.         ResultSet rs = null;
  702.         String sqlQuery = "";

  704.         if (this.driver.atomica) {
  705.             try {
  706.                 con = this.driver.getConnectionFromDatasource("getAccessoDatiGestioneToken");

  708.             } catch (Exception e) {
  709.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiGestioneToken] Exception accedendo al datasource :" + e.getMessage(),e);

  711.             }

  713.         } else
  714.             con = this.driver.globalConnection;

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

  718.         try {
  719.             AccessoDatiGestioneToken accessoDatiGestioneToken = new AccessoDatiGestioneToken();
  720.             
  721.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  722.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  723.             sqlQueryObject.addSelectField("*");
  724.             sqlQuery = sqlQueryObject.createSQLQuery();
  725.             stm = con.prepareStatement(sqlQuery);

  727.             this.driver.logDebug("eseguo query : " + sqlQuery);

  729.             rs = stm.executeQuery();

  731.             if (rs.next()) {
  732.                 readAccessoDatiGestioneToken(rs, accessoDatiGestioneToken);
  733.                 rs.close();
  734.                 stm.close();
  735.             }

  737.             return accessoDatiGestioneToken;

  739.         } catch (SQLException se) {
  740.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiGestioneToken] SqlException: " + se.getMessage(),se);
  741.         }catch (Exception se) {
  742.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiGestioneToken] Exception: " + se.getMessage(),se);
  743.         } finally {
  744.             //Chiudo statement and resultset
  745.             JDBCUtilities.closeResources(rs, stm);
  746.             this.driver.closeConnection(con);
  747.         }
  748.     }
  749.     private void readAccessoDatiGestioneToken(ResultSet rs, AccessoDatiGestioneToken accessoDatiGestioneToken) throws SQLException {
  750.         String tmpCache = rs.getString("token_statocache");
  751.         if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  752.             Cache cache = new Cache();

  754.             String tmpDim = rs.getString("token_dimensionecache");
  755.             if (tmpDim != null && !tmpDim.equals(""))
  756.                 cache.setDimensione(tmpDim);

  758.             String tmpAlg = rs.getString("token_algoritmocache");
  759.             if (tmpAlg.equalsIgnoreCase("LRU"))
  760.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  761.             else
  762.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  764.             String tmpIdle = rs.getString("token_idlecache");
  765.             String tmpLife = rs.getString("token_lifecache");

  767.             if (tmpIdle != null && !tmpIdle.equals(""))
  768.                 cache.setItemIdleTime(tmpIdle);
  769.             if (tmpLife != null && !tmpLife.equals(""))
  770.                 cache.setItemLifeSecond(tmpLife);

  772.             accessoDatiGestioneToken.setCache(cache);

  774.         }
  775.     }
  776.     
  777.     
  778.     
  779.     
  780.     
  781.     
  782.     protected AccessoDatiAttributeAuthority getAccessoDatiAttributeAuthority() throws DriverConfigurazioneException {

  784.         Connection con = null;
  785.         PreparedStatement stm = null;
  786.         ResultSet rs = null;
  787.         String sqlQuery = "";

  789.         if (this.driver.atomica) {
  790.             try {
  791.                 con = this.driver.getConnectionFromDatasource("getAccessoDatiAttributeAuthority");

  793.             } catch (Exception e) {
  794.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAttributeAuthority] Exception accedendo al datasource :" + e.getMessage(),e);

  796.             }

  798.         } else
  799.             con = this.driver.globalConnection;

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

  803.         try {
  804.             AccessoDatiAttributeAuthority accessoDatiAttributeAuthority = new AccessoDatiAttributeAuthority();
  805.             
  806.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  807.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  808.             sqlQueryObject.addSelectField("*");
  809.             sqlQuery = sqlQueryObject.createSQLQuery();
  810.             stm = con.prepareStatement(sqlQuery);

  812.             this.driver.logDebug("eseguo query : " + sqlQuery);

  814.             rs = stm.executeQuery();

  816.             if (rs.next()) {
  817.                 readAccessoDatiAttributeAuthority(rs, accessoDatiAttributeAuthority);
  818.                 rs.close();
  819.                 stm.close();
  820.             }

  822.             return accessoDatiAttributeAuthority;

  824.         } catch (SQLException se) {
  825.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAttributeAuthority] SqlException: " + se.getMessage(),se);
  826.         }catch (Exception se) {
  827.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiAttributeAuthority] Exception: " + se.getMessage(),se);
  828.         } finally {
  829.             //Chiudo statement and resultset
  830.             JDBCUtilities.closeResources(rs, stm);
  831.             this.driver.closeConnection(con);
  832.         }
  833.     }
  834.     private void readAccessoDatiAttributeAuthority(ResultSet rs, AccessoDatiAttributeAuthority accessoDatiAttributeAuthority) throws SQLException {
  835.         String tmpCache = rs.getString("aa_statocache");
  836.         if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  837.             Cache cache = new Cache();

  839.             String tmpDim = rs.getString("aa_dimensionecache");
  840.             if (tmpDim != null && !tmpDim.equals(""))
  841.                 cache.setDimensione(tmpDim);

  843.             String tmpAlg = rs.getString("aa_algoritmocache");
  844.             if (tmpAlg.equalsIgnoreCase("LRU"))
  845.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  846.             else
  847.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  849.             String tmpIdle = rs.getString("aa_idlecache");
  850.             String tmpLife = rs.getString("aa_lifecache");

  852.             if (tmpIdle != null && !tmpIdle.equals(""))
  853.                 cache.setItemIdleTime(tmpIdle);
  854.             if (tmpLife != null && !tmpLife.equals(""))
  855.                 cache.setItemLifeSecond(tmpLife);

  857.             accessoDatiAttributeAuthority.setCache(cache);

  859.         }
  860.     }
  861.     
  862.     
  863.     
  864.     
  865.     
  866.     
  867.     protected AccessoDatiKeystore getAccessoDatiKeystore() throws DriverConfigurazioneException {

  869.         Connection con = null;
  870.         PreparedStatement stm = null;
  871.         ResultSet rs = null;
  872.         String sqlQuery = "";

  874.         if (this.driver.atomica) {
  875.             try {
  876.                 con = this.driver.getConnectionFromDatasource("getAccessoDatiKeystore");

  878.             } catch (Exception e) {
  879.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiKeystore] Exception accedendo al datasource :" + e.getMessage(),e);

  881.             }

  883.         } else
  884.             con = this.driver.globalConnection;

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

  888.         try {
  889.             AccessoDatiKeystore accessoDatiKeystore = new AccessoDatiKeystore();

  891.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  892.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  893.             sqlQueryObject.addSelectField("*");
  894.             sqlQuery = sqlQueryObject.createSQLQuery();
  895.             stm = con.prepareStatement(sqlQuery);

  897.             this.driver.logDebug("eseguo query : " + sqlQuery);

  899.             rs = stm.executeQuery();

  901.             if (rs.next()) {
  902.                 readAccessoDatiKeystore(rs, accessoDatiKeystore);
  903.                 rs.close();
  904.                 stm.close();
  905.             }

  907.             return accessoDatiKeystore;

  909.         } catch (SQLException se) {
  910.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiKeystore] SqlException: " + se.getMessage(),se);
  911.         }catch (Exception se) {
  912.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiKeystore] Exception: " + se.getMessage(),se);
  913.         } finally {
  914.             //Chiudo statement and resultset
  915.             JDBCUtilities.closeResources(rs, stm);
  916.             this.driver.closeConnection(con);
  917.         }
  918.     }
  919.     private void readAccessoDatiKeystore(ResultSet rs, AccessoDatiKeystore accessoDatiKeystore) throws SQLException {
  920.         String tmpCache = rs.getString("keystore_statocache");
  921.         if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  922.             Cache cache = new Cache();

  924.             String tmpDim = rs.getString("keystore_dimensionecache");
  925.             if (tmpDim != null && !tmpDim.equals(""))
  926.                 cache.setDimensione(tmpDim);

  928.             String tmpAlg = rs.getString("keystore_algoritmocache");
  929.             if (tmpAlg.equalsIgnoreCase("LRU"))
  930.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  931.             else
  932.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  934.             String tmpIdle = rs.getString("keystore_idlecache");
  935.             String tmpLife = rs.getString("keystore_lifecache");
  936.             

  938.             if (tmpIdle != null && !tmpIdle.equals(""))
  939.                 cache.setItemIdleTime(tmpIdle);
  940.             if (tmpLife != null && !tmpLife.equals(""))
  941.                 cache.setItemLifeSecond(tmpLife);

  943.             accessoDatiKeystore.setCache(cache);
  944.             
  945.             readAccessoDatiKeystoreCrlLife(rs, accessoDatiKeystore);
  946.         }
  947.     }
  948.     private void readAccessoDatiKeystoreCrlLife(ResultSet rs, AccessoDatiKeystore accessoDatiKeystore) throws SQLException {
  949.         String tmpCrlLife = rs.getString("keystore_crl_lifecache");
  950.         
  951.         if (tmpCrlLife != null && !tmpCrlLife.equals(""))
  952.             accessoDatiKeystore.setCrlItemLifeSecond(tmpCrlLife);
  953.     }
  954.     
  955.     
  956.     
  957.     protected AccessoDatiConsegnaApplicativi getAccessoDatiConsegnaApplicativi() throws DriverConfigurazioneException {

  959.         Connection con = null;
  960.         PreparedStatement stm = null;
  961.         ResultSet rs = null;
  962.         String sqlQuery = "";

  964.         if (this.driver.atomica) {
  965.             try {
  966.                 con = this.driver.getConnectionFromDatasource("getAccessoDatiConsegnaApplicativi");

  968.             } catch (Exception e) {
  969.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiConsegnaApplicativi] Exception accedendo al datasource :" + e.getMessage(),e);

  971.             }

  973.         } else
  974.             con = this.driver.globalConnection;

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

  978.         try {
  979.             AccessoDatiConsegnaApplicativi accessoDatiConsegnaApplicativi = new AccessoDatiConsegnaApplicativi();
  980.             
  981.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  982.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  983.             sqlQueryObject.addSelectField("*");
  984.             sqlQuery = sqlQueryObject.createSQLQuery();
  985.             stm = con.prepareStatement(sqlQuery);

  987.             this.driver.logDebug("eseguo query : " + sqlQuery);

  989.             rs = stm.executeQuery();

  991.             if (rs.next()) {
  992.                 readAccessoDatiConsegnaApplicativi(rs, accessoDatiConsegnaApplicativi);
  993.                 rs.close();
  994.                 stm.close();
  995.             }

  997.             return accessoDatiConsegnaApplicativi;

  999.         } catch (SQLException se) {
  1000.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiConsegnaApplicativi] SqlException: " + se.getMessage(),se);
  1001.         }catch (Exception se) {
  1002.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiConsegnaApplicativi] Exception: " + se.getMessage(),se);
  1003.         } finally {
  1004.             //Chiudo statement and resultset
  1005.             JDBCUtilities.closeResources(rs, stm);
  1006.             this.driver.closeConnection(con);
  1007.         }
  1008.     }
  1009.     private void readAccessoDatiConsegnaApplicativi(ResultSet rs, AccessoDatiConsegnaApplicativi accessoDatiConsegnaApplicativi) throws SQLException {
  1010.         String tmpCache = rs.getString("consegna_statocache");
  1011.         if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  1012.             Cache cache = new Cache();

  1014.             String tmpDim = rs.getString("consegna_dimensionecache");
  1015.             if (tmpDim != null && !tmpDim.equals(""))
  1016.                 cache.setDimensione(tmpDim);

  1018.             String tmpAlg = rs.getString("consegna_algoritmocache");
  1019.             if (tmpAlg.equalsIgnoreCase("LRU"))
  1020.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  1021.             else
  1022.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  1024.             String tmpIdle = rs.getString("consegna_idlecache");
  1025.             String tmpLife = rs.getString("consegna_lifecache");
  1026.             
  1027.             if (tmpIdle != null && !tmpIdle.equals(""))
  1028.                 cache.setItemIdleTime(tmpIdle);
  1029.             if (tmpLife != null && !tmpLife.equals(""))
  1030.                 cache.setItemLifeSecond(tmpLife);

  1032.             accessoDatiConsegnaApplicativi.setCache(cache);
  1033.             
  1034.         }
  1035.     }
  1036.     
  1037.     
  1038.     protected AccessoDatiRichieste getAccessoDatiRichieste() throws DriverConfigurazioneException {

  1040.         Connection con = null;
  1041.         PreparedStatement stm = null;
  1042.         ResultSet rs = null;
  1043.         String sqlQuery = "";

  1045.         if (this.driver.atomica) {
  1046.             try {
  1047.                 con = this.driver.getConnectionFromDatasource("getAccessoDatiRichieste");

  1049.             } catch (Exception e) {
  1050.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiRichieste] Exception accedendo al datasource :" + e.getMessage(),e);

  1052.             }

  1054.         } else
  1055.             con = this.driver.globalConnection;

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

  1059.         try {
  1060.             AccessoDatiRichieste accessoDatiRichieste = new AccessoDatiRichieste();
  1061.             
  1062.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1063.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  1064.             sqlQueryObject.addSelectField("*");
  1065.             sqlQuery = sqlQueryObject.createSQLQuery();
  1066.             stm = con.prepareStatement(sqlQuery);

  1068.             this.driver.logDebug("eseguo query : " + sqlQuery);

  1070.             rs = stm.executeQuery();

  1072.             if (rs.next()) {
  1073.                 readAccessoDatiRichieste(rs, accessoDatiRichieste);
  1074.                 rs.close();
  1075.                 stm.close();
  1076.             }

  1078.             return accessoDatiRichieste;

  1080.         } catch (SQLException se) {
  1081.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiRichieste] SqlException: " + se.getMessage(),se);
  1082.         }catch (Exception se) {
  1083.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getAccessoDatiRichieste] Exception: " + se.getMessage(),se);
  1084.         } finally {
  1085.             //Chiudo statement and resultset
  1086.             JDBCUtilities.closeResources(rs, stm);
  1087.             this.driver.closeConnection(con);
  1088.         }
  1089.     }
  1090.     private void readAccessoDatiRichieste(ResultSet rs, AccessoDatiRichieste accessoDatiRichieste) throws SQLException {
  1091.         String tmpCache = rs.getString("dati_richieste_statocache");
  1092.         if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  1093.             Cache cache = new Cache();

  1095.             String tmpDim = rs.getString("dati_richieste_dimensionecache");
  1096.             if (tmpDim != null && !tmpDim.equals(""))
  1097.                 cache.setDimensione(tmpDim);

  1099.             String tmpAlg = rs.getString("dati_richieste_algoritmocache");
  1100.             if (tmpAlg.equalsIgnoreCase("LRU"))
  1101.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  1102.             else
  1103.                 cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  1105.             String tmpIdle = rs.getString("dati_richieste_idlecache");
  1106.             String tmpLife = rs.getString("dati_richieste_lifecache");
  1107.             
  1108.             if (tmpIdle != null && !tmpIdle.equals(""))
  1109.                 cache.setItemIdleTime(tmpIdle);
  1110.             if (tmpLife != null && !tmpLife.equals(""))
  1111.                 cache.setItemLifeSecond(tmpLife);

  1113.             accessoDatiRichieste.setCache(cache);

  1115.         }
  1116.     }
  1117.     
  1118.     

  1120.     protected void createAccessoDatiAutorizzazione(AccessoDatiAutorizzazione accessoDatiAutorizzazione) throws DriverConfigurazioneException {

  1122.         Connection con = null;
  1123.         boolean error = false;

  1125.         if (this.driver.atomica) {
  1126.             try {
  1127.                 con = this.driver.getConnectionFromDatasource("createAccessoDatiAutorizzazione");
  1128.                 con.setAutoCommit(false);
  1129.             } catch (Exception e) {
  1130.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoDatiAutorizzazione] Exception accedendo al datasource :" + e.getMessage(),e);

  1132.             }

  1134.         } else
  1135.             con = this.driver.globalConnection;

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

  1139.         try {
  1140.             this.driver.logDebug("CRUDAccessoDatiAutorizzazione type = 1");
  1141.             DriverConfigurazioneDB_configLIB.CRUDAccessoDatiAutorizzazione(1, accessoDatiAutorizzazione, con);

  1143.         } catch (Exception qe) {
  1144.             error = true;
  1145.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoDatiAutorizzazione] Errore durante la createAccessoDatiAutorizzazione : " + qe.getMessage(),qe);
  1146.         } finally {

  1148.             this.driver.closeConnection(error,con);
  1149.         }
  1150.     }

  1152.     protected void updateAccessoDatiAutorizzazione(AccessoDatiAutorizzazione accessoDatiAutorizzazione) throws DriverConfigurazioneException {
  1153.         Connection con = null;
  1154.         boolean error = false;

  1156.         if (this.driver.atomica) {
  1157.             try {
  1158.                 con = this.driver.getConnectionFromDatasource("updateAccessoDatiAutorizzazione");
  1159.                 con.setAutoCommit(false);
  1160.             } catch (Exception e) {
  1161.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateAccessoDatiAutorizzazione] Exception accedendo al datasource :" + e.getMessage(),e);

  1163.             }

  1165.         } else
  1166.             con = this.driver.globalConnection;

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

  1170.         try {
  1171.             this.driver.logDebug("CRUDAccessoDatiAutorizzazione type = 2");
  1172.             DriverConfigurazioneDB_configLIB.CRUDAccessoDatiAutorizzazione(2, accessoDatiAutorizzazione, con);

  1174.         } catch (Exception qe) {
  1175.             error = true;
  1176.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateAccessoDatiAutorizzazione] Errore durante la updateAccessoDatiAutorizzazione : " + qe.getMessage(),qe);
  1177.         } finally {

  1179.             this.driver.closeConnection(error,con);
  1180.         }
  1181.     }

  1183.     protected void deleteAccessoDatiAutorizzazione(AccessoDatiAutorizzazione accessoDatiAutorizzazione) throws DriverConfigurazioneException {
  1184.         Connection con = null;
  1185.         boolean error = false;

  1187.         if (this.driver.atomica) {
  1188.             try {
  1189.                 con = this.driver.getConnectionFromDatasource("deleteAccessoDatiAutorizzazione");
  1190.                 con.setAutoCommit(false);
  1191.             } catch (Exception e) {
  1192.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteAccessoDatiAutorizzazione] Exception accedendo al datasource :" + e.getMessage(),e);

  1194.             }

  1196.         } else
  1197.             con = this.driver.globalConnection;

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

  1201.         try {
  1202.             this.driver.logDebug("CRUDAccessoDatiAutorizzazione type = 3");
  1203.             DriverConfigurazioneDB_configLIB.CRUDAccessoDatiAutorizzazione(3, accessoDatiAutorizzazione, con);

  1205.         } catch (Exception qe) {
  1206.             error = true;
  1207.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteAccessoDatiAutorizzazione] Errore durante la deleteAccessoDatiAutorizzazione : " + qe.getMessage(),qe);
  1208.         } finally {

  1210.             this.driver.closeConnection(error,con);
  1211.         }
  1212.     }
  1213.     

  1215.     /**
  1216.      * Restituisce la gestione dell'errore di default definita nella Porta di
  1217.      * Dominio
  1218.      * 
  1219.      * @return La gestione dell'errore
  1220.      * 
  1221.      */
  1222.     protected StatoServiziPdd getStatoServiziPdD() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  1224.         Connection con = null;
  1225.         PreparedStatement stm = null;
  1226.         ResultSet rs = null;
  1227.         PreparedStatement stmFiltri = null;
  1228.         ResultSet rsFiltri = null;

  1230.         String sqlQuery = "";

  1232.         if (this.driver.atomica) {
  1233.             try {
  1234.                 con = this.driver.getConnectionFromDatasource("getStatoServiziPdD");
  1235.             } catch (Exception e) {
  1236.                 throw new DriverConfigurazioneException("[getServiziAttiviPdD] Exception accedendo al datasource :" + e.getMessage(),e);

  1238.             }
  1239.         } else
  1240.             con = this.driver.globalConnection;

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

  1244.         try {
  1245.             StatoServiziPdd servizi = null;

  1247.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1248.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_PDD);
  1249.             sqlQuery = sqlQueryObject.createSQLQuery();

  1251.             ISQLQueryObject sqlQueryObjectFiltri = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1252.             sqlQueryObjectFiltri.addFromTable(CostantiDB.SERVIZI_PDD_FILTRI);
  1253.             sqlQueryObjectFiltri.addWhereCondition("id_servizio_pdd=?");
  1254.             String sqlQueryFiltro = sqlQueryObjectFiltri.createSQLQuery();

  1256.             this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery));
  1257.             stm = con.prepareStatement(sqlQuery);
  1258.             rs = stm.executeQuery();


  1261.             while (rs.next()) {

  1263.                 if(servizi==null){
  1264.                     servizi = new StatoServiziPdd();
  1265.                 }

  1267.                 long id = rs.getLong("id");

  1269.                 String tipo = rs.getString("componente");

  1271.                 int servizio = rs.getInt("stato");
  1272.                 StatoFunzionalita stato = null;
  1273.                 if(servizio==0)
  1274.                     stato = CostantiConfigurazione.DISABILITATO;
  1275.                 else if(servizio==1)
  1276.                     stato = CostantiConfigurazione.ABILITATO;
  1277.                 else
  1278.                     stato = CostantiConfigurazione.ABILITATO; // default

  1280.                 if(CostantiDB.COMPONENTE_SERVIZIO_PD.equals(tipo)){

  1282.                     StatoServiziPddPortaDelegata sPD = new StatoServiziPddPortaDelegata();
  1283.                     sPD.setStato(stato);

  1285.                     this.driver.logDebug("eseguo query filtro: " + DBUtils.formatSQLString(sqlQueryFiltro,id));
  1286.                     stmFiltri = con.prepareStatement(sqlQueryFiltro);
  1287.                     stmFiltri.setLong(1, id);
  1288.                     rsFiltri = stmFiltri.executeQuery();
  1289.                     riempiFiltriServiziPdD(rsFiltri, sPD.getFiltroAbilitazioneList(), sPD.getFiltroDisabilitazioneList());
  1290.                     rsFiltri.close();
  1291.                     stmFiltri.close();

  1293.                     servizi.setPortaDelegata(sPD);
  1294.                 }
  1295.                 else if(CostantiDB.COMPONENTE_SERVIZIO_PA.equals(tipo)){

  1297.                     StatoServiziPddPortaApplicativa sPA = new StatoServiziPddPortaApplicativa();
  1298.                     sPA.setStato(stato);

  1300.                     this.driver.logDebug("eseguo query filtro: " + DBUtils.formatSQLString(sqlQueryFiltro,id));
  1301.                     stmFiltri = con.prepareStatement(sqlQueryFiltro);
  1302.                     stmFiltri.setLong(1, id);
  1303.                     rsFiltri = stmFiltri.executeQuery();
  1304.                     riempiFiltriServiziPdD(rsFiltri, sPA.getFiltroAbilitazioneList(), sPA.getFiltroDisabilitazioneList());
  1305.                     rsFiltri.close();
  1306.                     stmFiltri.close();

  1308.                     servizi.setPortaApplicativa(sPA);
  1309.                 }
  1310.                 else if(CostantiDB.COMPONENTE_SERVIZIO_IM.equals(tipo)){

  1312.                     StatoServiziPddIntegrationManager sIM = new StatoServiziPddIntegrationManager();
  1313.                     sIM.setStato(stato);

  1315.                     servizi.setIntegrationManager(sIM);
  1316.                 }
  1317.             } 

  1319.             if(servizi==null)
  1320.                 throw new DriverConfigurazioneNotFound("Configurazione servizi attivi sulla PdD non presente");

  1322.             rs.close();
  1323.             stm.close();

  1325.             return servizi;

  1327.         } catch (SQLException se) {
  1328.             throw new DriverConfigurazioneException("[getServiziAttiviPdD]  SqlException: " + se.getMessage(),se);
  1329.         }catch (DriverConfigurazioneNotFound e) {
  1330.             throw new DriverConfigurazioneNotFound(e);
  1331.         }catch (Exception se) {
  1332.             throw new DriverConfigurazioneException("[getServiziAttiviPdD]  Exception: " + se.getMessage(),se);
  1333.         } finally {
  1334.             //Chiudo statement and resultset
  1335.             JDBCUtilities.closeResources(rsFiltri, stmFiltri);
  1336.             JDBCUtilities.closeResources(rs, stm);
  1337.             this.driver.closeConnection(con);
  1338.         }

  1340.     }

  1342.     private void riempiFiltriServiziPdD(ResultSet rsFiltri,List<TipoFiltroAbilitazioneServizi> listaAbilitazioni,List<TipoFiltroAbilitazioneServizi> listaDisabilitazioni) throws SQLException{
  1343.         while(rsFiltri.next()){

  1345.             String tipo = rsFiltri.getString("tipo_filtro");

  1347.             TipoFiltroAbilitazioneServizi tipoFiltro = new TipoFiltroAbilitazioneServizi();

  1349.             String tipoSoggettoFruitore = rsFiltri.getString("tipo_soggetto_fruitore");
  1350.             tipoFiltro.setTipoSoggettoFruitore(tipoSoggettoFruitore);
  1351.             String soggettoFruitore = rsFiltri.getString("soggetto_fruitore");
  1352.             tipoFiltro.setSoggettoFruitore(soggettoFruitore);
  1353.             String identificativoPortaFruitore = rsFiltri.getString("identificativo_porta_fruitore");
  1354.             tipoFiltro.setIdentificativoPortaFruitore(identificativoPortaFruitore);

  1356.             String tipoSoggettoErogatore = rsFiltri.getString("tipo_soggetto_erogatore");
  1357.             tipoFiltro.setTipoSoggettoErogatore(tipoSoggettoErogatore);
  1358.             String soggettoErogatore = rsFiltri.getString("soggetto_erogatore");
  1359.             tipoFiltro.setSoggettoErogatore(soggettoErogatore);
  1360.             String identificativoPortaErogatore = rsFiltri.getString("identificativo_porta_erogatore");
  1361.             tipoFiltro.setIdentificativoPortaErogatore(identificativoPortaErogatore);

  1363.             String tipoServizio = rsFiltri.getString("tipo_servizio");
  1364.             tipoFiltro.setTipoServizio(tipoServizio);
  1365.             String servizio = rsFiltri.getString("servizio");
  1366.             tipoFiltro.setServizio(servizio);
  1367.             Integer versioneServizio = rsFiltri.getInt("versione_servizio");
  1368.             if(rsFiltri.wasNull()==false){
  1369.                 tipoFiltro.setVersioneServizio(versioneServizio);
  1370.             }

  1372.             String azione = rsFiltri.getString("azione");
  1373.             tipoFiltro.setAzione(azione);

  1375.             if(CostantiDB.TIPO_FILTRO_ABILITAZIONE_SERVIZIO_PDD.equals(tipo)){
  1376.                 listaAbilitazioni.add(tipoFiltro);
  1377.             }
  1378.             else{
  1379.                 listaDisabilitazioni.add(tipoFiltro);
  1380.             }

  1382.         }
  1383.     }



  1387.     /**
  1388.      * Crea le informazioni sui servizi attivi della PdD
  1389.      * 
  1390.      * @param servizi
  1391.      * @throws DriverConfigurazioneException
  1392.      */
  1393.     protected void createStatoServiziPdD(StatoServiziPdd servizi) throws DriverConfigurazioneException{
  1394.         Connection con = null;
  1395.         boolean error = false;

  1397.         if (this.driver.atomica) {
  1398.             try {
  1399.                 con = this.driver.getConnectionFromDatasource("createStatoServiziPdD");
  1400.                 con.setAutoCommit(false);
  1401.             } catch (Exception e) {
  1402.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createServiziAttiviPdD] Exception accedendo al datasource :" + e.getMessage(),e);

  1404.             }

  1406.         } else
  1407.             con = this.driver.globalConnection;

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

  1411.         try {
  1412.             this.driver.logDebug("createServiziAttiviPdD type = 1");
  1413.             DriverConfigurazioneDB_configLIB.CRUDServiziPdD(1, servizi, con);

  1415.         } catch (Exception qe) {
  1416.             error = true;
  1417.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createServiziAttiviPdD] Errore durante la createServiziAttiviPdD : " + qe.getMessage(),qe);
  1418.         } finally {

  1420.             this.driver.closeConnection(error,con);
  1421.         }
  1422.     }

  1424.     /**
  1425.      * Aggiorna le informazioni sui servizi attivi della PdD
  1426.      * 
  1427.      * @param servizi
  1428.      * @throws DriverConfigurazioneException
  1429.      */
  1430.     protected void updateStatoServiziPdD(StatoServiziPdd servizi) throws DriverConfigurazioneException{
  1431.         Connection con = null;
  1432.         boolean error = false;

  1434.         if (this.driver.atomica) {
  1435.             try {
  1436.                 con = this.driver.getConnectionFromDatasource("updateStatoServiziPdD");
  1437.                 con.setAutoCommit(false);
  1438.             } catch (Exception e) {
  1439.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateServiziAttiviPdD] Exception accedendo al datasource :" + e.getMessage(),e);

  1441.             }

  1443.         } else
  1444.             con = this.driver.globalConnection;

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

  1448.         try {
  1449.             this.driver.logDebug("createServiziAttiviPdD type = 2");
  1450.             DriverConfigurazioneDB_configLIB.CRUDServiziPdD(2, servizi, con);

  1452.         } catch (Exception qe) {
  1453.             error = true;
  1454.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateServiziAttiviPdD] Errore durante la updateServiziAttiviPdD : " + qe.getMessage(),qe);
  1455.         } finally {

  1457.             this.driver.closeConnection(error,con);
  1458.         }
  1459.     }


  1462.     /**
  1463.      * Elimina le informazioni sui servizi attivi della PdD
  1464.      * 
  1465.      * @param servizi
  1466.      * @throws DriverConfigurazioneException
  1467.      */
  1468.     protected void deleteStatoServiziPdD(StatoServiziPdd servizi) throws DriverConfigurazioneException{
  1469.         Connection con = null;
  1470.         boolean error = false;

  1472.         if (this.driver.atomica) {
  1473.             try {
  1474.                 con = this.driver.getConnectionFromDatasource("deleteStatoServiziPdD");
  1475.                 con.setAutoCommit(false);
  1476.             } catch (Exception e) {
  1477.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteServiziAttiviPdD] Exception accedendo al datasource :" + e.getMessage(),e);

  1479.             }

  1481.         } else
  1482.             con = this.driver.globalConnection;

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

  1486.         try {
  1487.             this.driver.logDebug("createServiziAttiviPdD type = 3");
  1488.             DriverConfigurazioneDB_configLIB.CRUDServiziPdD(3, servizi, con);

  1490.         } catch (Exception qe) {
  1491.             error = true;
  1492.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteServiziAttiviPdD] Errore durante la deleteServiziAttiviPdD : " + qe.getMessage(),qe);
  1493.         } finally {

  1495.             this.driver.closeConnection(error,con);
  1496.         }
  1497.     }





  1503.     


  1506.     /**
  1507.      * Restituisce le proprieta' di sistema utilizzate dalla PdD
  1508.      *
  1509.      * @return proprieta' di sistema
  1510.      * 
  1511.      */
  1512.     protected SystemProperties getSystemPropertiesPdD() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1513.         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1514.         return getSystemPropertiesPdDEngine(driverBYOK);
  1515.     }
  1516.     protected SystemProperties getSystemPropertiesPdDWithoutBIOK() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1517.         return getSystemPropertiesPdDEngine(null);
  1518.     }
  1519.     private SystemProperties getSystemPropertiesPdDEngine(IDriverBYOK driverBYOK) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  1521.         Connection con = null;
  1522.         PreparedStatement stm = null;
  1523.         ResultSet rs = null;

  1525.         String sqlQuery = "";

  1527.         if (this.driver.atomica) {
  1528.             try {
  1529.                 con = this.driver.getConnectionFromDatasource("getSystemPropertiesPdD");
  1530.             } catch (Exception e) {
  1531.                 throw new DriverConfigurazioneException("[getSystemPropertiesPdD] Exception accedendo al datasource :" + e.getMessage(),e);

  1533.             }
  1534.         } else
  1535.             con = this.driver.globalConnection;

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

  1539.         try {
  1540.             SystemProperties systemProperties = null;

  1542.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1543.             sqlQueryObject.addFromTable(CostantiDB.SYSTEM_PROPERTIES_PDD);
  1544.             sqlQuery = sqlQueryObject.createSQLQuery();

  1546.             this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery));
  1547.             stm = con.prepareStatement(sqlQuery);
  1548.             rs = stm.executeQuery();


  1551.             while (rs.next()) {

  1553.                 if(systemProperties==null){
  1554.                     systemProperties = new SystemProperties();
  1555.                 }

  1557.                 long id = rs.getLong("id");

  1559.                 String nome = rs.getString(CostantiDB.SYSTEM_PROPERTIES_PDD_COLUMN_NOME);
  1560.                 
  1561.                 Property sp = new Property();
  1562.                 sp.setNome(nome);
  1563.                                 
  1564.                 String plainValue = rs.getString(CostantiDB.SYSTEM_PROPERTIES_PDD_COLUMN_VALUE);
  1565.                 String encValue = rs.getString(CostantiDB.SYSTEM_PROPERTIES_PDD_COLUMN_ENC_VALUE);
  1566.                 if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1567.                     if(driverBYOK!=null) {
  1568.                         sp.setValore(driverBYOK.unwrapAsString(encValue));
  1569.                     }
  1570.                     else {
  1571.                         sp.setValore(encValue);
  1572.                     }
  1573.                 }
  1574.                 else {
  1575.                     sp.setValore(plainValue);
  1576.                 }

  1578.                 sp.setId(id);
  1579.                 systemProperties.addSystemProperty(sp);

  1581.             } 

  1583.             if(systemProperties==null)
  1584.                 throw new DriverConfigurazioneNotFound("System Properties non presenti");

  1586.             rs.close();
  1587.             stm.close();

  1589.             return systemProperties;

  1591.         } catch (SQLException se) {
  1592.             throw new DriverConfigurazioneException("[getSystemPropertiesPdD]  SqlException: " + se.getMessage(),se);
  1593.         }catch (DriverConfigurazioneNotFound e) {
  1594.             throw new DriverConfigurazioneNotFound(e);
  1595.         }catch (Exception se) {
  1596.             throw new DriverConfigurazioneException("[getSystemPropertiesPdD]  Exception: " + se.getMessage(),se);
  1597.         } finally {
  1598.             //Chiudo statement and resultset
  1599.             JDBCUtilities.closeResources(rs, stm);
  1600.             this.driver.closeConnection(con);
  1601.         }

  1603.     }
  1604.     protected List<String> getEncryptedSystemPropertiesPdD() throws DriverConfigurazioneException {
  1605.         List<String> l = new ArrayList<>();
  1606.         try {
  1607.             SystemProperties s = getSystemPropertiesPdDEngine(null);
  1608.             if(s!=null && s.sizeSystemPropertyList()>0) {
  1609.                 for (Property p : s.getSystemPropertyList()) {
  1610.                     if(p.getValore()!=null && StringUtils.isNotEmpty(p.getValore()) && BYOKUtilities.isWrappedValue(p.getValore())) {
  1611.                         l.add(p.getNome());
  1612.                     }
  1613.                 }
  1614.             }
  1615.         }catch(DriverConfigurazioneNotFound notFound) {
  1616.             // ignore
  1617.         }
  1618.         return l;
  1619.     }
  1620.     
  1621.     protected void createSystemPropertiesPdD(SystemProperties systemProperties) throws DriverConfigurazioneException{
  1622.         Connection con = null;
  1623.         boolean error = false;

  1625.         if (this.driver.atomica) {
  1626.             try {
  1627.                 con = this.driver.getConnectionFromDatasource("createSystemPropertiesPdD");
  1628.                 con.setAutoCommit(false);
  1629.             } catch (Exception e) {
  1630.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createSystemPropertiesPdD] Exception accedendo al datasource :" + e.getMessage(),e);

  1632.             }

  1634.         } else
  1635.             con = this.driver.globalConnection;

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

  1639.         try {
  1640.             this.driver.logDebug("createSystemPropertiesPdD type = 1");
  1641.             DriverConfigurazioneDB_configLIB.CRUDSystemPropertiesPdD(1, systemProperties, con, this.driver.getDriverWrapBYOK());

  1643.         } catch (Exception qe) {
  1644.             error = true;
  1645.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createSystemPropertiesPdD] Errore durante la createSystemPropertiesPdD : " + qe.getMessage(),qe);
  1646.         } finally {

  1648.             this.driver.closeConnection(error,con);
  1649.         }
  1650.     }

  1652.     /**
  1653.      * Aggiorna le informazioni sulle proprieta' di sistema utilizzate dalla PdD
  1654.      * 
  1655.      * @param systemProperties
  1656.      * @throws DriverConfigurazioneException
  1657.      */
  1658.     protected void updateSystemPropertiesPdD(SystemProperties systemProperties) throws DriverConfigurazioneException{
  1659.         Connection con = null;
  1660.         boolean error = false;

  1662.         if (this.driver.atomica) {
  1663.             try {
  1664.                 con = this.driver.getConnectionFromDatasource("updateSystemPropertiesPdD");
  1665.                 con.setAutoCommit(false);
  1666.             } catch (Exception e) {
  1667.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateSystemPropertiesPdD] Exception accedendo al datasource :" + e.getMessage(),e);

  1669.             }

  1671.         } else
  1672.             con = this.driver.globalConnection;

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

  1676.         try {
  1677.             this.driver.logDebug("updateSystemPropertiesPdD type = 2");
  1678.             DriverConfigurazioneDB_configLIB.CRUDSystemPropertiesPdD(2, systemProperties, con, this.driver.getDriverWrapBYOK());

  1680.         } catch (Exception qe) {
  1681.             error = true;
  1682.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateSystemPropertiesPdD] Errore durante la updateSystemPropertiesPdD : " + qe.getMessage(),qe);
  1683.         } finally {

  1685.             this.driver.closeConnection(error,con);
  1686.         }
  1687.     }


  1690.     /**
  1691.      * Elimina le informazioni sulle proprieta' di sistema utilizzate dalla PdD
  1692.      * 
  1693.      * @param systemProperties
  1694.      * @throws DriverConfigurazioneException
  1695.      */
  1696.     protected void deleteSystemPropertiesPdD(SystemProperties systemProperties) throws DriverConfigurazioneException{
  1697.         Connection con = null;
  1698.         boolean error = false;

  1700.         if (this.driver.atomica) {
  1701.             try {
  1702.                 con = this.driver.getConnectionFromDatasource("deleteSystemPropertiesPdD");
  1703.                 con.setAutoCommit(false);
  1704.             } catch (Exception e) {
  1705.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteSystemPropertiesPdD] Exception accedendo al datasource :" + e.getMessage(),e);

  1707.             }

  1709.         } else
  1710.             con = this.driver.globalConnection;

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

  1714.         try {
  1715.             this.driver.logDebug("deleteSystemPropertiesPdD type = 3");
  1716.             DriverConfigurazioneDB_configLIB.CRUDSystemPropertiesPdD(3, systemProperties, con, this.driver.getDriverWrapBYOK());

  1718.         } catch (Exception qe) {
  1719.             error = true;
  1720.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteSystemPropertiesPdD] Errore durante la deleteSystemPropertiesPdD : " + qe.getMessage(),qe);
  1721.         } finally {

  1723.             this.driver.closeConnection(error,con);
  1724.         }
  1725.     }
  1726.     
  1727.     protected ConfigurazioneUrlInvocazioneRegola getUrlInvocazioneRegola(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1728.         Connection con = null;
  1729.         PreparedStatement stm = null;
  1730.         ResultSet rs = null;
  1731.         
  1732.         String sqlQuery = "";

  1734.         if (this.driver.atomica) {
  1735.             try {
  1736.                 con = this.driver.getConnectionFromDatasource("getUrlInvocazioneRegola");
  1737.             } catch (Exception e) {
  1738.                 throw new DriverConfigurazioneException("[getUrlInvocazioneRegola] Exception accedendo al datasource :" + e.getMessage(),e);

  1740.             }
  1741.         } else
  1742.             con = this.driver.globalConnection;

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

  1746.         ConfigurazioneUrlInvocazioneRegola regola = null;
  1747.         
  1748.         try {
  1749.             
  1750.             if(nome==null) {
  1751.                 throw new DriverConfigurazioneException("Nome regola non indicato");
  1752.             }
  1753.             
  1754.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1755.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  1756.             sqlQueryObject.addSelectField("*");
  1757.             sqlQueryObject.addWhereCondition("nome=?");
  1758.             sqlQueryObject.addOrderBy("nome");
  1759.             sqlQueryObject.setSortType(true);   
  1760.             sqlQuery = sqlQueryObject.createSQLQuery();
  1761.             stm = con.prepareStatement(sqlQuery);
  1762.             stm.setString(1, nome);
  1763.             rs = stm.executeQuery();
  1764.             while(rs.next()){
  1765.                 
  1766.                 regola = new ConfigurazioneUrlInvocazioneRegola();
  1767.                 readRegola(regola, rs);
  1768.                 
  1769.             }
  1770.             rs.close();
  1771.             stm.close();

  1773.     
  1774.         }catch (DriverConfigurazioneNotFound notFound) {
  1775.             throw notFound;
  1776.         }catch (SQLException se) {
  1777.             throw new DriverConfigurazioneException("[getUrlInvocazioneRegola]  SqlException: " + se.getMessage(),se);
  1778.         }catch (Exception se) {
  1779.             throw new DriverConfigurazioneException("[getUrlInvocazioneRegolas]  Exception: " + se.getMessage(),se);
  1780.         }
  1781.         finally {
  1782.             JDBCUtilities.closeResources(rs, stm);
  1783.             this.driver.closeConnection(con);
  1784.         }

  1786.         if(regola!=null) {
  1787.             return regola;
  1788.         }
  1789.         throw new DriverConfigurazioneNotFound("Regola '"+nome+"' non esistente");
  1790.     }
  1791.     
  1792.     protected boolean existsUrlInvocazioneRegola(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1793.         Connection con = null;
  1794.         PreparedStatement stm = null;
  1795.         ResultSet rs = null;
  1796.         
  1797.         String sqlQuery = "";

  1799.         if (this.driver.atomica) {
  1800.             try {
  1801.                 con = this.driver.getConnectionFromDatasource("existsUrlInvocazioneRegola");
  1802.             } catch (Exception e) {
  1803.                 throw new DriverConfigurazioneException("[existsUrlInvocazioneRegola] Exception accedendo al datasource :" + e.getMessage(),e);

  1805.             }
  1806.         } else
  1807.             con = this.driver.globalConnection;

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

  1811.         try {
  1812.             
  1813.             if(nome==null) {
  1814.                 throw new DriverConfigurazioneException("Nome regola non indicato");
  1815.             }
  1816.             
  1817.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1818.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  1819.             sqlQueryObject.addSelectField("*");
  1820.             sqlQueryObject.addWhereCondition("nome=?");
  1821.             sqlQueryObject.addOrderBy("nome");
  1822.             sqlQueryObject.setSortType(true);   
  1823.             sqlQuery = sqlQueryObject.createSQLQuery();
  1824.             stm = con.prepareStatement(sqlQuery);
  1825.             stm.setString(1, nome);
  1826.             rs = stm.executeQuery();
  1827.             while(rs.next()){
  1828.                 
  1829.                 return true;
  1830.                 
  1831.             }
  1832.             rs.close();
  1833.             stm.close();

  1835.     
  1836.         }catch (SQLException se) {
  1837.             throw new DriverConfigurazioneException("[existsUrlInvocazioneRegola]  SqlException: " + se.getMessage(),se);
  1838.         }catch (Exception se) {
  1839.             throw new DriverConfigurazioneException("[existsUrlInvocazioneRegola]  Exception: " + se.getMessage(),se);
  1840.         }
  1841.         finally {
  1842.             JDBCUtilities.closeResources(rs, stm);
  1843.             this.driver.closeConnection(con);
  1844.         }

  1846.         return false;
  1847.     }

  1849.     private void readRegola(ConfigurazioneUrlInvocazioneRegola regola, ResultSet rs) throws Exception {
  1850.         regola.setId(rs.getLong("id"));
  1851.         regola.setNome(rs.getString("nome"));
  1852.         regola.setPosizione(rs.getInt("posizione"));
  1853.         regola.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("stato")));
  1854.         regola.setDescrizione(rs.getString("descrizione"));
  1855.         if(rs.getInt("regexpr") == CostantiDB.TRUE) {
  1856.             regola.setRegexpr(true);
  1857.         }else {
  1858.             regola.setRegexpr(false);
  1859.         }
  1860.         regola.setRegola(rs.getString("regola"));
  1861.         // Fix stringa vuota in Oracle, impostato dalla console e non accettato da Oracle che lo traduce in null e fa schiantare per via del NOT NULL sul db
  1862.         String s = rs.getString("contesto_esterno");
  1863.         if(CostantiConfigurazione.REGOLA_PROXY_PASS_CONTESTO_VUOTO.equals(s)) {
  1864.             s = "";
  1865.         }
  1866.         regola.setContestoEsterno(s);
  1867.         regola.setBaseUrl(rs.getString("base_url"));
  1868.         regola.setProtocollo(rs.getString("protocollo"));
  1869.         regola.setRuolo(DriverConfigurazioneDBLib.getEnumRuoloContesto(rs.getString("ruolo")));
  1870.         regola.setServiceBinding(DriverConfigurazioneDBLib.getEnumServiceBinding(rs.getString("service_binding")));
  1871.         String tipoSoggetto = rs.getString("tipo_soggetto");
  1872.         String nomeSoggetto = rs.getString("nome_soggetto");
  1873.         if(tipoSoggetto!=null && !"".equals(tipoSoggetto) && nomeSoggetto!=null && !"".equals(nomeSoggetto)) {
  1874.             regola.setSoggetto(new IdSoggetto(new IDSoggetto(tipoSoggetto, nomeSoggetto)));
  1875.         }
  1876.     }

  1878.     protected void createUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
  1879.         Connection con = null;
  1880.         boolean error = false;

  1882.         if (this.driver.atomica) {
  1883.             try {
  1884.                 con = this.driver.getConnectionFromDatasource("createUrlInvocazioneRegola");
  1885.                 con.setAutoCommit(false);
  1886.             } catch (Exception e) {
  1887.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createUrlInvocazioneRegola] Exception accedendo al datasource :" + e.getMessage(),e);

  1889.             }

  1891.         } else
  1892.             con = this.driver.globalConnection;

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

  1896.         try {
  1897.             this.driver.logDebug("CRUDUrlInvocazioneRegola type = 1");
  1898.             DriverConfigurazioneDB_configLIB.CRUDUrlInvocazioneRegola(1, regola, con);

  1900.         } catch (Exception qe) {
  1901.             error = true;
  1902.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createUrlInvocazioneRegola] Errore durante la create : " + qe.getMessage(),qe);
  1903.         } finally {

  1905.             this.driver.closeConnection(error,con);
  1906.         }
  1907.     }

  1909.     protected void updateUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
  1910.         Connection con = null;
  1911.         boolean error = false;

  1913.         if (this.driver.atomica) {
  1914.             try {
  1915.                 con = this.driver.getConnectionFromDatasource("updateUrlInvocazioneRegola");
  1916.                 con.setAutoCommit(false);
  1917.             } catch (Exception e) {
  1918.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateUrlInvocazioneRegola] Exception accedendo al datasource :" + e.getMessage(),e);

  1920.             }

  1922.         } else
  1923.             con = this.driver.globalConnection;

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

  1927.         try {
  1928.             this.driver.logDebug("CRUDUrlInvocazioneRegola type = 2");
  1929.             DriverConfigurazioneDB_configLIB.CRUDUrlInvocazioneRegola(2, regola, con);

  1931.         } catch (Exception qe) {
  1932.             error = true;
  1933.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateUrlInvocazioneRegola] Errore durante l'aggiornamento : " + qe.getMessage(),qe);
  1934.         } finally {

  1936.             this.driver.closeConnection(error,con);
  1937.         }
  1938.     }

  1940.     protected void deleteUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
  1941.         Connection con = null;
  1942.         boolean error = false;

  1944.         if (this.driver.atomica) {
  1945.             try {
  1946.                 con = this.driver.getConnectionFromDatasource("deleteUrlInvocazioneRegola");
  1947.                 con.setAutoCommit(false);
  1948.             } catch (Exception e) {
  1949.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteUrlInvocazioneRegola] Exception accedendo al datasource :" + e.getMessage(),e);

  1951.             }

  1953.         } else
  1954.             con = this.driver.globalConnection;

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

  1958.         try {
  1959.             this.driver.logDebug("CRUDUrlInvocazioneRegola type = 3");
  1960.             DriverConfigurazioneDB_configLIB.CRUDUrlInvocazioneRegola(3, regola, con);

  1962.         } catch (Exception qe) {
  1963.             error = true;
  1964.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteUrlInvocazioneRegola] Errore durante l'eliminazione : " + qe.getMessage(),qe);
  1965.         } finally {

  1967.             this.driver.closeConnection(error,con);
  1968.         }
  1969.     }
  1970.     
  1971.     
  1972.     
  1973.     
  1974.     
  1975.     
  1976.     
  1977.     /**
  1978.      * Restituisce la configurazione generale della Porta di Dominio
  1979.      * 
  1980.      * @return Configurazione
  1981.      * 
  1982.      */
  1983.     protected Configurazione getConfigurazioneGenerale() throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  1984.         // ritorna la configurazione generale della PdD

  1986.         Connection con = null;
  1987.         PreparedStatement stm = null;
  1988.         ResultSet rs = null;
  1989.         PreparedStatement stm1 = null;
  1990.         ResultSet rs1 = null;
  1991.         PreparedStatement stm2 = null;
  1992.         ResultSet rs2 = null;

  1994.         String sqlQuery = "";

  1996.         if (this.driver.atomica) {
  1997.             try {
  1998.                 con = this.driver.getConnectionFromDatasource("getConfigurazioneGenerale");

  2000.             } catch (Exception e) {
  2001.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getConfigurazioneGenerale] Exception accedendo al datasource :" + e.getMessage(),e);

  2003.             }

  2005.         } else
  2006.             con = this.driver.globalConnection;

  2008.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  2009.         Configurazione config = new Configurazione();
  2010.         try {
  2011.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2012.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  2013.             sqlQueryObject.addSelectField("*");
  2014.             sqlQuery = sqlQueryObject.createSQLQuery();

  2016.             this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery));
  2017.             stm = con.prepareStatement(sqlQuery);
  2018.             rs = stm.executeQuery();

  2020.             if (rs.next()) {

  2022.                 Attachments attachments = new Attachments();
  2023.                 attachments.setGestioneManifest(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("gestione_manifest")));
  2024.                 config.setAttachments(attachments);

  2026.                 //config.setId(rs.getLong("id"));

  2028.                 IndirizzoRisposta indirizzoRisposta = new IndirizzoRisposta();
  2029.                 indirizzoRisposta.setUtilizzo(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("indirizzo_telematico")));
  2030.                 config.setIndirizzoRisposta(indirizzoRisposta);

  2032.                 String cadenza_inoltro = rs.getString("cadenza_inoltro");
  2033.                 InoltroBusteNonRiscontrate inoltroBusteNonRiscontrate = new InoltroBusteNonRiscontrate();
  2034.                 inoltroBusteNonRiscontrate.setCadenza(cadenza_inoltro);
  2035.                 config.setInoltroBusteNonRiscontrate(inoltroBusteNonRiscontrate);

  2037.                 String autenticazione = rs.getString("auth_integration_manager");
  2038.                 IntegrationManager integrationManager = new IntegrationManager();
  2039.                 integrationManager.setAutenticazione(autenticazione);
  2040.                 config.setIntegrationManager(integrationManager);

  2042.                 //String stato_cache = rs.getString("statocache");
  2043.                 //String dim_cache = rs.getString("dimensionecache");
  2044.                 //String alog_cache = rs.getString("algoritmocache");
  2045.                 //String idle_cache = rs.getString("idlecache");
  2046.                 //String life_cache = rs.getString("lifecache");


  2049.                 boolean routingEnabled =  false;
  2050.                 if(CostantiConfigurazione.ABILITATO.equals(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("routing_enabled"))))
  2051.                     routingEnabled = true;
  2052.                 RoutingTable rt = new RoutingTable();
  2053.                 rt.setAbilitata(routingEnabled);
  2054.                 config.setRoutingTable(rt);


  2057.                 String validazioneContenuti_stato = rs.getString("validazione_contenuti_stato");
  2058.                 String validazioneContenuti_tipo = rs.getString("validazione_contenuti_tipo");
  2059.                 String validazioneContenuti_acceptMtomMessage = rs.getString("validazione_contenuti_mtom");
  2060.                 if(  (validazioneContenuti_stato!=null && !validazioneContenuti_stato.equals(""))  
  2061.                         ||
  2062.                         (validazioneContenuti_tipo!=null && !validazioneContenuti_tipo.equals(""))  
  2063.                         ||
  2064.                         (validazioneContenuti_acceptMtomMessage!=null && !validazioneContenuti_acceptMtomMessage.equals("")))
  2065.                 {
  2066.                     ValidazioneContenutiApplicativi val = new ValidazioneContenutiApplicativi();
  2067.                     if((validazioneContenuti_stato!=null && !validazioneContenuti_stato.equals(""))  )
  2068.                         val.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(validazioneContenuti_stato));
  2069.                     if((validazioneContenuti_tipo!=null && !validazioneContenuti_tipo.equals(""))  )
  2070.                         val.setTipo(DriverConfigurazioneDBLib.getEnumValidazioneContenutiApplicativiTipo(validazioneContenuti_tipo));
  2071.                     if((validazioneContenuti_acceptMtomMessage!=null && !validazioneContenuti_acceptMtomMessage.equals(""))  )
  2072.                         val.setAcceptMtomMessage(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(validazioneContenuti_acceptMtomMessage));
  2073.                     config.setValidazioneContenutiApplicativi(val);
  2074.                 }


  2077.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2078.                 sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_INVOCAZIONE);
  2079.                 sqlQueryObject.addSelectField("*");
  2080.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2081.                 stm1 = con.prepareStatement(sqlQuery);
  2082.                 rs1 = stm1.executeQuery();
  2083.                 if(rs1.next()){
  2084.                     ConfigurazioneUrlInvocazione configurazioneUrlInvocazione = new ConfigurazioneUrlInvocazione();
  2085.                     configurazioneUrlInvocazione.setBaseUrl(rs1.getString("base_url"));
  2086.                     configurazioneUrlInvocazione.setBaseUrlFruizione(rs1.getString("base_url_fruizione"));
  2087.                     config.setUrlInvocazione(configurazioneUrlInvocazione);
  2088.                 }
  2089.                 rs1.close();
  2090.                 stm1.close();
  2091.                 
  2092.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2093.                 sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  2094.                 sqlQueryObject.addSelectField("*");
  2095.                 sqlQueryObject.addOrderBy("posizione");
  2096.                 sqlQueryObject.addOrderBy("nome");
  2097.                 sqlQueryObject.setSortType(true);   
  2098.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2099.                 stm1 = con.prepareStatement(sqlQuery);
  2100.                 rs1 = stm1.executeQuery();
  2101.                 while(rs1.next()){
  2102.                     
  2103.                     if(config.getUrlInvocazione()==null) {
  2104.                         config.setUrlInvocazione(new ConfigurazioneUrlInvocazione());
  2105.                     }
  2106.                     
  2107.                     ConfigurazioneUrlInvocazioneRegola regola = new ConfigurazioneUrlInvocazioneRegola();
  2108.                     readRegola(regola, rs1);
  2109.                     config.getUrlInvocazione().addRegola(regola);
  2110.                 }
  2111.                 rs1.close();
  2112.                 stm1.close();

  2114.                 
  2115.                 String multitenantStato = rs.getString("multitenant_stato");
  2116.                 String multitenantStatoSoggettiFruitori = rs.getString("multitenant_fruizioni");
  2117.                 String multitenantStatoSoggettiErogatori = rs.getString("multitenant_erogazioni");
  2118.                 config.setMultitenant(new ConfigurazioneMultitenant());
  2119.                 config.getMultitenant().setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(multitenantStato));
  2120.                 config.getMultitenant().setFruizioneSceltaSoggettiErogatori(DriverConfigurazioneDBLib.getEnumPortaDelegataSoggettiErogatori(multitenantStatoSoggettiFruitori));
  2121.                 config.getMultitenant().setErogazioneSceltaSoggettiFruitori(DriverConfigurazioneDBLib.getEnumPortaApplicativaSoggettiFruitori(multitenantStatoSoggettiErogatori));

  2123.                 String msg_diag_severita = rs.getString("msg_diag_severita");
  2124.                 String msg_diag_severita_log4j = rs.getString("msg_diag_severita_log4j");
  2125.                 MessaggiDiagnostici messaggiDiagnostici = new MessaggiDiagnostici();
  2126.                 messaggiDiagnostici.setSeveritaLog4j(DriverConfigurazioneDBLib.getEnumSeverita(msg_diag_severita_log4j));
  2127.                 messaggiDiagnostici.setSeverita(DriverConfigurazioneDBLib.getEnumSeverita(msg_diag_severita));
  2128.                 //messaggi diagnostici appender
  2129.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2130.                 sqlQueryObject.addFromTable(CostantiDB.MSG_DIAGN_APPENDER);
  2131.                 sqlQueryObject.addSelectField("*");
  2132.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2133.                 stm1 = con.prepareStatement(sqlQuery);
  2134.                 rs1 = stm1.executeQuery();

  2136.                 while(rs1.next()){
  2137.                     OpenspcoopAppender appender = new OpenspcoopAppender();
  2138.                     //tipo appender
  2139.                     appender.setTipo(rs1.getString("tipo"));
  2140.                     long idAppender = rs1.getLong("id");
  2141.                     appender.setId(idAppender);
  2142.                     //prendo le proprieta
  2143.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2144.                     sqlQueryObject.addFromTable(CostantiDB.MSG_DIAGN_APPENDER_PROP);
  2145.                     sqlQueryObject.addSelectField("*");
  2146.                     sqlQueryObject.addWhereCondition("id_appender = ?");
  2147.                     sqlQuery = sqlQueryObject.createSQLQuery();
  2148.                     stm2 = con.prepareStatement(sqlQuery);
  2149.                     stm2.setLong(1, idAppender);
  2150.                     rs2 = stm2.executeQuery();
  2151.                     Property appender_prop = null;
  2152.                     while(rs2.next())
  2153.                     {
  2154.                         appender_prop = new Property();
  2155.                         //proprieta
  2156.                         appender_prop.setId(rs2.getLong("id"));
  2157.                         appender_prop.setNome(rs2.getString("nome"));
  2158.                         appender_prop.setValore(rs2.getString("valore"));
  2159.                         appender.addProperty(appender_prop);
  2160.                     }
  2161.                     rs2.close();
  2162.                     stm2.close();
  2163.                     messaggiDiagnostici.addOpenspcoopAppender(appender);
  2164.                 }
  2165.                 rs1.close();
  2166.                 stm1.close();

  2168.                 //messaggi diagnostici datasource
  2169.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2170.                 sqlQueryObject.addFromTable(CostantiDB.MSG_DIAGN_DS);
  2171.                 sqlQueryObject.addSelectField("*");
  2172.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2173.                 stm1 = con.prepareStatement(sqlQuery);
  2174.                 rs1 = stm1.executeQuery();

  2176.                 while(rs1.next()){
  2177.                     OpenspcoopSorgenteDati openspcoopDS = new OpenspcoopSorgenteDati();
  2178.                     openspcoopDS.setNome(rs1.getString("nome"));
  2179.                     openspcoopDS.setNomeJndi(rs1.getString("nome_jndi"));
  2180.                     openspcoopDS.setTipoDatabase(rs1.getString("tipo_database"));
  2181.                     long idDS = rs1.getLong("id");
  2182.                     openspcoopDS.setId(idDS);
  2183.                     //prendo le proprieta
  2184.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2185.                     sqlQueryObject.addFromTable(CostantiDB.MSG_DIAGN_DS_PROP);
  2186.                     sqlQueryObject.addSelectField("*");
  2187.                     sqlQueryObject.addWhereCondition("id_prop = ?");
  2188.                     sqlQuery = sqlQueryObject.createSQLQuery();
  2189.                     stm2 = con.prepareStatement(sqlQuery);
  2190.                     stm2.setLong(1, idDS);
  2191.                     rs2 = stm2.executeQuery();
  2192.                     Property ds_prop = null;
  2193.                     while(rs2.next())
  2194.                     {
  2195.                         ds_prop = new Property();
  2196.                         //proprieta
  2197.                         ds_prop.setId(rs2.getLong("id"));
  2198.                         ds_prop.setNome(rs2.getString("nome"));
  2199.                         ds_prop.setValore(rs2.getString("valore"));
  2200.                         openspcoopDS.addProperty(ds_prop);
  2201.                     }
  2202.                     rs2.close();
  2203.                     stm2.close();
  2204.                     messaggiDiagnostici.addOpenspcoopSorgenteDati(openspcoopDS);
  2205.                 }
  2206.                 rs1.close();
  2207.                 stm1.close();

  2209.                 config.setMessaggiDiagnostici(messaggiDiagnostici);

  2211.                 
  2212.                 
  2213.                 //Tracciamento
  2214.                 Tracciamento tracciamento = new Tracciamento();
  2215.                                 
  2216.                 String traccBuste = rs.getString("tracciamento_buste");
  2217.                 tracciamento.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(traccBuste));
  2218.                 
  2219.                             
  2220.                 // porta applicativa
  2221.                 String traccEsitiPA = rs.getString("tracciamento_esiti");
  2222.                 String transazioniTempiElaborazionePA = rs.getString("transazioni_tempi");
  2223.                 String transazioniTokenPA = rs.getString("transazioni_token");
  2224.                 TracciamentoConfigurazione tracciamentoDatabasePA = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, null, 
  2225.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA,
  2226.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  2227.                 TracciamentoConfigurazione tracciamentoFiletracePA = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, null, 
  2228.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA,
  2229.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  2230.                 TracciamentoConfigurazioneFiletrace tracciamentoFiletraceDetailsPA = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazioneFiletrace(con, null, 
  2231.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  2232.                 if( 
  2233.                         (traccEsitiPA!=null && StringUtils.isNotEmpty(traccEsitiPA))
  2234.                         ||
  2235.                         (transazioniTempiElaborazionePA!=null && StringUtils.isNotEmpty(transazioniTempiElaborazionePA))
  2236.                         ||
  2237.                         (transazioniTokenPA!=null && StringUtils.isNotEmpty(transazioniTokenPA))
  2238.                         ||
  2239.                         tracciamentoDatabasePA!=null
  2240.                         ||
  2241.                         tracciamentoFiletracePA!=null
  2242.                         ||
  2243.                         tracciamentoFiletraceDetailsPA!=null
  2244.                         ) {
  2245.                     tracciamento.setPortaApplicativa(new ConfigurazioneTracciamentoPorta());
  2246.                     tracciamento.getPortaApplicativa().setEsiti(traccEsitiPA);
  2247.                     if( 
  2248.                             (transazioniTempiElaborazionePA!=null && StringUtils.isNotEmpty(transazioniTempiElaborazionePA))
  2249.                             ||
  2250.                             (transazioniTokenPA!=null && StringUtils.isNotEmpty(transazioniTokenPA))
  2251.                             ) {
  2252.                         tracciamento.getPortaApplicativa().setTransazioni(new Transazioni());
  2253.                         tracciamento.getPortaApplicativa().getTransazioni().setTempiElaborazione(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(transazioniTempiElaborazionePA));
  2254.                         tracciamento.getPortaApplicativa().getTransazioni().setToken(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(transazioniTokenPA));
  2255.                     }
  2256.                     tracciamento.getPortaApplicativa().setDatabase(tracciamentoDatabasePA);
  2257.                     tracciamento.getPortaApplicativa().setFiletrace(tracciamentoFiletracePA);
  2258.                     tracciamento.getPortaApplicativa().setFiletraceConfig(tracciamentoFiletraceDetailsPA);
  2259.                 }

  2261.                 
  2262.                 // porta delegata
  2263.                 String traccEsitiPD = rs.getString("tracciamento_esiti_pd");
  2264.                 String transazioniTempiElaborazionePD = rs.getString("transazioni_tempi_pd");
  2265.                 String transazioniTokenPD = rs.getString("transazioni_token_pd");
  2266.                 TracciamentoConfigurazione tracciamentoDatabasePD = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, null, 
  2267.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD,
  2268.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  2269.                 TracciamentoConfigurazione tracciamentoFiletracePD = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, null, 
  2270.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD,
  2271.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  2272.                 TracciamentoConfigurazioneFiletrace tracciamentoFiletraceDetailsPD = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazioneFiletrace(con, null, 
  2273.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  2274.                 if( 
  2275.                         (traccEsitiPD!=null && StringUtils.isNotEmpty(traccEsitiPD))
  2276.                         ||
  2277.                         (transazioniTempiElaborazionePD!=null && StringUtils.isNotEmpty(transazioniTempiElaborazionePD))
  2278.                         ||
  2279.                         (transazioniTokenPD!=null && StringUtils.isNotEmpty(transazioniTokenPD))
  2280.                         ||
  2281.                         tracciamentoDatabasePD!=null
  2282.                         ||
  2283.                         tracciamentoFiletracePD!=null
  2284.                         ||
  2285.                         tracciamentoFiletraceDetailsPD!=null
  2286.                         ) {
  2287.                     tracciamento.setPortaDelegata(new ConfigurazioneTracciamentoPorta());
  2288.                     tracciamento.getPortaDelegata().setEsiti(traccEsitiPD);
  2289.                     if( 
  2290.                             (transazioniTempiElaborazionePD!=null && StringUtils.isNotEmpty(transazioniTempiElaborazionePD))
  2291.                             ||
  2292.                             (transazioniTokenPD!=null && StringUtils.isNotEmpty(transazioniTokenPD))
  2293.                             ) {
  2294.                         tracciamento.getPortaDelegata().setTransazioni(new Transazioni());
  2295.                         tracciamento.getPortaDelegata().getTransazioni().setTempiElaborazione(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(transazioniTempiElaborazionePD));
  2296.                         tracciamento.getPortaDelegata().getTransazioni().setToken(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(transazioniTokenPD));
  2297.                     }
  2298.                     tracciamento.getPortaDelegata().setDatabase(tracciamentoDatabasePD);
  2299.                     tracciamento.getPortaDelegata().setFiletrace(tracciamentoFiletracePD);
  2300.                     tracciamento.getPortaDelegata().setFiletraceConfig(tracciamentoFiletraceDetailsPD);
  2301.                 }
  2302.                 
  2303.                 
  2304.                 
  2305.                 
  2306.                 //appender tracciamento
  2307.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2308.                 sqlQueryObject.addFromTable(CostantiDB.TRACCIAMENTO_APPENDER);
  2309.                 sqlQueryObject.addSelectField("*");
  2310.                 sqlQuery = sqlQueryObject.createSQLQuery();

  2312.                 stm1 = con.prepareStatement(sqlQuery);
  2313.                 rs1 = stm1.executeQuery();
  2314.                 //recuper tutti gli appender e le prop di ogni appender
  2315.                 while(rs1.next()){
  2316.                     OpenspcoopAppender trac_appender = new OpenspcoopAppender();
  2317.                     //tipo appender
  2318.                     trac_appender.setTipo(rs1.getString("tipo"));
  2319.                     long idAppenderTrac = rs1.getLong("id");
  2320.                     trac_appender.setId(idAppenderTrac);
  2321.                     //prendo le proprieta
  2322.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2323.                     sqlQueryObject.addFromTable(CostantiDB.TRACCIAMENTO_APPENDER_PROP);
  2324.                     sqlQueryObject.addSelectField("*");
  2325.                     sqlQueryObject.addWhereCondition("id_appender = ?");
  2326.                     sqlQuery = sqlQueryObject.createSQLQuery();
  2327.                     stm2 = con.prepareStatement(sqlQuery);
  2328.                     stm2.setLong(1, idAppenderTrac);
  2329.                     rs2 = stm2.executeQuery();
  2330.                     Property trac_appender_prop = null;
  2331.                     while(rs2.next())
  2332.                     {
  2333.                         //setto le prop di questo appender
  2334.                         trac_appender_prop = new Property();
  2335.                         //proprieta
  2336.                         trac_appender_prop.setId(rs2.getLong("id"));
  2337.                         trac_appender_prop.setNome(rs2.getString("nome"));
  2338.                         trac_appender_prop.setValore(rs2.getString("valore"));
  2339.                         //aggiungo la prop all'appender
  2340.                         trac_appender.addProperty(trac_appender_prop);
  2341.                     }
  2342.                     rs2.close();
  2343.                     stm2.close();
  2344.                     tracciamento.addOpenspcoopAppender(trac_appender);
  2345.                 }
  2346.                 rs1.close();
  2347.                 stm1.close();

  2349.                 //datasource tracciamento
  2350.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2351.                 sqlQueryObject.addFromTable(CostantiDB.TRACCIAMENTO_DS);
  2352.                 sqlQueryObject.addSelectField("*");
  2353.                 sqlQuery = sqlQueryObject.createSQLQuery();

  2355.                 stm1 = con.prepareStatement(sqlQuery);
  2356.                 rs1 = stm1.executeQuery();
  2357.                 //recuper tutti i datasource e le prop di ogni datasource
  2358.                 while(rs1.next()){
  2359.                     OpenspcoopSorgenteDati trac_ds = new OpenspcoopSorgenteDati();
  2360.                     trac_ds.setNome(rs1.getString("nome"));
  2361.                     trac_ds.setNomeJndi(rs1.getString("nome_jndi"));
  2362.                     trac_ds.setTipoDatabase(rs1.getString("tipo_database"));
  2363.                     long idDsTrac = rs1.getLong("id");
  2364.                     trac_ds.setId(idDsTrac);
  2365.                     //prendo le proprieta
  2366.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2367.                     sqlQueryObject.addFromTable(CostantiDB.TRACCIAMENTO_DS_PROP);
  2368.                     sqlQueryObject.addSelectField("*");
  2369.                     sqlQueryObject.addWhereCondition("id_prop = ?");
  2370.                     sqlQuery = sqlQueryObject.createSQLQuery();
  2371.                     stm2 = con.prepareStatement(sqlQuery);
  2372.                     stm2.setLong(1, idDsTrac);
  2373.                     rs2 = stm2.executeQuery();
  2374.                     Property trac_ds_prop = null;
  2375.                     while(rs2.next())
  2376.                     {
  2377.                         //setto le prop di questo datasource
  2378.                         trac_ds_prop = new Property();
  2379.                         //proprieta
  2380.                         trac_ds_prop.setId(rs2.getLong("id"));
  2381.                         trac_ds_prop.setNome(rs2.getString("nome"));
  2382.                         trac_ds_prop.setValore(rs2.getString("valore"));
  2383.                         //aggiungo la prop al datasource
  2384.                         trac_ds.addProperty(trac_ds_prop);
  2385.                     }
  2386.                     rs2.close();
  2387.                     stm2.close();
  2388.                     tracciamento.addOpenspcoopSorgenteDati(trac_ds);
  2389.                 }
  2390.                 rs1.close();
  2391.                 stm1.close();

  2393.                 config.setTracciamento(tracciamento);

  2395.                 
  2396.                 
  2397.                 // Dump
  2398.                 String dump_stato = rs.getString("dump");
  2399.                 String dump_pd = rs.getString("dump_bin_pd");
  2400.                 String dump_pa = rs.getString("dump_bin_pa");
  2401.                 Dump dump = new Dump();
  2402.                 dump.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(dump_stato));
  2403.                 dump.setDumpBinarioPortaDelegata(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(dump_pd));
  2404.                 if(dump.getDumpBinarioPortaDelegata()==null){
  2405.                     dump.setDumpBinarioPortaDelegata(StatoFunzionalita.DISABILITATO); // default
  2406.                 }
  2407.                 dump.setDumpBinarioPortaApplicativa(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(dump_pa));
  2408.                 if(dump.getDumpBinarioPortaApplicativa()==null){
  2409.                     dump.setDumpBinarioPortaApplicativa(StatoFunzionalita.DISABILITATO); // default
  2410.                 }
  2411.                 //appender dump
  2412.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2413.                 sqlQueryObject.addFromTable(CostantiDB.DUMP_APPENDER);
  2414.                 sqlQueryObject.addSelectField("*");
  2415.                 sqlQuery = sqlQueryObject.createSQLQuery();

  2417.                 stm1 = con.prepareStatement(sqlQuery);
  2418.                 rs1 = stm1.executeQuery();
  2419.                 //recuper tutti gli appender e le prop di ogni appender
  2420.                 while(rs1.next()){
  2421.                     OpenspcoopAppender dump_appender = new OpenspcoopAppender();
  2422.                     //tipo appender
  2423.                     dump_appender.setTipo(rs1.getString("tipo"));
  2424.                     long idAppenderDump = rs1.getLong("id");
  2425.                     dump_appender.setId(idAppenderDump);
  2426.                     //prendo le proprieta
  2427.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2428.                     sqlQueryObject.addFromTable(CostantiDB.DUMP_APPENDER_PROP);
  2429.                     sqlQueryObject.addSelectField("*");
  2430.                     sqlQueryObject.addWhereCondition("id_appender = ?");
  2431.                     sqlQuery = sqlQueryObject.createSQLQuery();
  2432.                     stm2 = con.prepareStatement(sqlQuery);
  2433.                     stm2.setLong(1, idAppenderDump);
  2434.                     rs2 = stm2.executeQuery();
  2435.                     Property dump_appender_prop = null;
  2436.                     while(rs2.next())
  2437.                     {
  2438.                         //setto le prop di questo appender
  2439.                         dump_appender_prop = new Property();
  2440.                         //proprieta
  2441.                         dump_appender_prop.setId(rs2.getLong("id"));
  2442.                         dump_appender_prop.setNome(rs2.getString("nome"));
  2443.                         dump_appender_prop.setValore(rs2.getString("valore"));
  2444.                         //aggiungo la prop all'appender
  2445.                         dump_appender.addProperty(dump_appender_prop);
  2446.                     }
  2447.                     rs2.close();
  2448.                     stm2.close();
  2449.                     dump.addOpenspcoopAppender(dump_appender);
  2450.                 }
  2451.                 rs1.close();
  2452.                 stm1.close();

  2454.                 // dump_config
  2455.                 DumpConfigurazione dumpConfig = DriverConfigurazioneDB_dumpLIB.readDumpConfigurazione(con, null, CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG);
  2456.                 if(dumpConfig!=null) {
  2457.                     // backward compatibility, lo uso sia per erogazione che per fruizione
  2458.                     dump.setConfigurazionePortaApplicativa(dumpConfig);
  2459.                     dump.setConfigurazionePortaDelegata(dumpConfig);
  2460.                 }
  2461.                 else {
  2462.                     DumpConfigurazione dumpConfigPA = DriverConfigurazioneDB_dumpLIB.readDumpConfigurazione(con, null, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  2463.                     dump.setConfigurazionePortaApplicativa(dumpConfigPA);
  2464.                     
  2465.                     DumpConfigurazione dumpConfigPD = DriverConfigurazioneDB_dumpLIB.readDumpConfigurazione(con, null, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  2466.                     dump.setConfigurazionePortaDelegata(dumpConfigPD);
  2467.                 }
  2468.                 
  2469.                 
  2470.                 config.setDump(dump);
  2471.                 
  2472.                 
  2473.                 Risposte risposte = new Risposte();
  2474.                 risposte.setConnessione(DriverConfigurazioneDBLib.getEnumTipoConnessioneRisposte(rs.getString("mod_risposta")));
  2475.                 config.setRisposte(risposte);

  2477.                 String val_controllo = rs.getString("validazione_controllo");
  2478.                 String val_stato = rs.getString("validazione_stato");
  2479.                 String val_manifest = rs.getString("validazione_manifest");
  2480.                 String val_profilo = rs.getString("validazione_profilo");
  2481.                 ValidazioneBuste validazioneBuste = new ValidazioneBuste();
  2482.                 validazioneBuste.setControllo(DriverConfigurazioneDBLib.getEnumValidazioneBusteTipoControllo(val_controllo));
  2483.                 validazioneBuste.setManifestAttachments(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(val_manifest));
  2484.                 validazioneBuste.setProfiloCollaborazione(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(val_profilo));
  2485.                 validazioneBuste.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(val_stato));
  2486.                 config.setValidazioneBuste(validazioneBuste);

  2488.                 // Gestione CORS
  2489.                 config.setGestioneCors(new CorsConfigurazione());
  2490.                 this.porteDriver.readConfigurazioneCors(config.getGestioneCors(), rs);
  2491.                 
  2492.                 // Gestione CacheResponse
  2493.                 config.setResponseCaching(new ResponseCachingConfigurazioneGenerale());
  2494.                 
  2495.                 config.getResponseCaching().setConfigurazione(new ResponseCachingConfigurazione());
  2496.                 this.porteDriver.readResponseCaching(null, true, false, config.getResponseCaching().getConfigurazione(), rs, con);
  2497.                 
  2498.                 String tmpCache = rs.getString("response_cache_statocache");
  2499.                 if (CostantiConfigurazione.ABILITATO.equals(tmpCache)) {
  2500.                     Cache cache = new Cache();

  2502.                     String tmpDim = rs.getString("response_cache_dimensionecache");
  2503.                     if (tmpDim != null && !tmpDim.equals(""))
  2504.                         cache.setDimensione(tmpDim);

  2506.                     String tmpAlg = rs.getString("response_cache_algoritmocache");
  2507.                     if (tmpAlg.equalsIgnoreCase("LRU"))
  2508.                         cache.setAlgoritmo(CostantiConfigurazione.CACHE_LRU);
  2509.                     else
  2510.                         cache.setAlgoritmo(CostantiConfigurazione.CACHE_MRU);

  2512.                     String tmpIdle = rs.getString("response_cache_idlecache");
  2513.                     String tmpLife = rs.getString("response_cache_lifecache");

  2515.                     if (tmpIdle != null && !tmpIdle.equals(""))
  2516.                         cache.setItemIdleTime(tmpIdle);
  2517.                     if (tmpLife != null && !tmpLife.equals(""))
  2518.                         cache.setItemLifeSecond(tmpLife);

  2520.                     config.getResponseCaching().setCache(cache);

  2522.                 }
  2523.                 
  2524.                 // Canali
  2525.                 String canali_stato = rs.getString("canali_stato");
  2526.                 config.setGestioneCanali(new CanaliConfigurazione());
  2527.                 config.getGestioneCanali().setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(canali_stato));
  2528.                 if(StatoFunzionalita.ABILITATO.equals(config.getGestioneCanali().getStato())) {
  2529.                     DriverConfigurazioneDB_canaliLIB.readCanaliConfigurazione(con, config.getGestioneCanali(), true);
  2530.                 }
  2531.                 
  2532.                 // Handlers
  2533.                 ConfigurazioneMessageHandlers requestHandlers = DriverConfigurazioneDB_handlerLIB.readConfigurazioneMessageHandlers(con, null, null, true);
  2534.                 ConfigurazioneMessageHandlers responseHandlers = DriverConfigurazioneDB_handlerLIB.readConfigurazioneMessageHandlers(con, null, null, false);
  2535.                 ConfigurazioneServiceHandlers serviceHandlers = DriverConfigurazioneDB_handlerLIB.readConfigurazioneServiceHandlers(con, null, null, false);
  2536.                 if(requestHandlers!=null || responseHandlers!=null || serviceHandlers!=null) {
  2537.                     config.setConfigurazioneHandler(new ConfigurazioneGeneraleHandler());
  2538.                     config.getConfigurazioneHandler().setRequest(requestHandlers);
  2539.                     config.getConfigurazioneHandler().setResponse(responseHandlers);
  2540.                     config.getConfigurazioneHandler().setService(serviceHandlers);
  2541.                 }
  2542.                 
  2543.                 ExtendedInfoManager extInfoManager = ExtendedInfoManager.getInstance();
  2544.                 IExtendedInfo extInfoConfigurazioneDriver = extInfoManager.newInstanceExtendedInfoConfigurazione();
  2545.                 if(extInfoConfigurazioneDriver!=null){
  2546.                     List<Object> list = extInfoConfigurazioneDriver.getAllExtendedInfo(con, this.driver.log, config);
  2547.                     if(list!=null && !list.isEmpty()){
  2548.                         config.setExtendedInfoList(list);
  2549.                     }
  2550.                 }
  2551.                 
  2552.             } else {
  2553.                 throw new DriverConfigurazioneNotFound("[DriverConfigurazioneDB::getConfigurazioneGenerale] Configurazione non presente.");
  2554.             }

  2556.         } catch (DriverConfigurazioneNotFound e) {
  2557.             throw e;
  2558.         }catch (Exception se) {
  2559.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getConfigurazioneGenerale] Exception: " + se.getMessage(),se);
  2560.         } finally {
  2561.             //Chiudo statement and resultset
  2562.             JDBCUtilities.closeResources(rs, stm);
  2563.             JDBCUtilities.closeResources(rs1, stm1);
  2564.             JDBCUtilities.closeResources(rs2, stm2);
  2565.             this.driver.closeConnection(con);
  2566.         }


  2569.         // Altre parti di configurazione. Le prendo dopo aver rilasciato la connessione, per permettere di far funzionare il driver anche con pool di una sola connessione. 

  2571.         // - GestioneErrore
  2572.         ConfigurazioneGestioneErrore cge = null;

  2574.         try{
  2575.             GestioneErrore ge = this.gestioneErroreDriver.getGestioneErroreComponenteIntegrazione();

  2577.             if(ge!=null){
  2578.                 if(cge==null) cge = new ConfigurazioneGestioneErrore();
  2579.                 cge.setComponenteIntegrazione(ge);
  2580.             }
  2581.         }catch (Exception e) {
  2582.             // ignore
  2583.         }

  2585.         try{
  2586.             GestioneErrore ge = this.gestioneErroreDriver.getGestioneErroreComponenteCooperazione();
  2587.             if(ge!=null){
  2588.                 if(cge==null) cge = new ConfigurazioneGestioneErrore();
  2589.                 cge.setComponenteCooperazione(ge);
  2590.             }
  2591.         }catch (Exception e) {
  2592.             // ignore
  2593.         }

  2595.         if(cge!=null) config.setGestioneErrore(cge);

  2597.         // - AccessoRegistro
  2598.         try{
  2599.             config.setAccessoRegistro(getAccessoRegistro());
  2600.         }catch (Exception e) {
  2601.             // ignore
  2602.         }
  2603.         
  2604.         // - AccessoConfigurazione
  2605.         try{
  2606.             config.setAccessoConfigurazione(getAccessoConfigurazione());
  2607.         }catch (Exception e) {
  2608.             // ignore
  2609.         }
  2610.         
  2611.         // - AccessoDatiAutorizzazione
  2612.         try{
  2613.             config.setAccessoDatiAutorizzazione(getAccessoDatiAutorizzazione());
  2614.         }catch (Exception e) {
  2615.             // ignore
  2616.         }
  2617.         
  2618.         // - AccessoDatiAutenticazione
  2619.         try{
  2620.             config.setAccessoDatiAutenticazione(getAccessoDatiAutenticazione());
  2621.         }catch (Exception e) {
  2622.             // ignore
  2623.         }
  2624.         
  2625.         // - AccessoDatiGestioneToken
  2626.         try{
  2627.             config.setAccessoDatiGestioneToken(getAccessoDatiGestioneToken());
  2628.         }catch (Exception e) {
  2629.             // ignore
  2630.         }
  2631.         
  2632.         // - AccessoDatiAttributeAuthority
  2633.         try{
  2634.             config.setAccessoDatiAttributeAuthority(getAccessoDatiAttributeAuthority());
  2635.         }catch (Exception e) {
  2636.             // ignore
  2637.         }
  2638.         
  2639.         // - AccessoDatiKeystore
  2640.         try{
  2641.             config.setAccessoDatiKeystore(getAccessoDatiKeystore());
  2642.         }catch (Exception e) {
  2643.             // ignore
  2644.         }
  2645.         
  2646.         // - AccessoDatiConsegnaApplicativi
  2647.         try{
  2648.             config.setAccessoDatiConsegnaApplicativi(getAccessoDatiConsegnaApplicativi());
  2649.         }catch (Exception e) {
  2650.             // ignore
  2651.         }
  2652.         
  2653.         // - AccessoDatiRichieste
  2654.         try{
  2655.             config.setAccessoDatiRichieste(getAccessoDatiRichieste());
  2656.         }catch (Exception e) {
  2657.             // ignore
  2658.         }

  2660.         // - RoutingTable
  2661.         try{
  2662.             config.setRoutingTable(this.routingTableDriver.getRoutingTable());
  2663.         }catch (Exception e) {
  2664.             // ignore
  2665.         }

  2667.         // - ServiziPdD
  2668.         try{
  2669.             config.setStatoServiziPdd(getStatoServiziPdD());
  2670.         }catch (Exception e) {
  2671.             // ignore
  2672.         }

  2674.         // - SystemProperties
  2675.         try{
  2676.             config.setSystemProperties(getSystemPropertiesPdD());
  2677.         }catch (Exception e) {
  2678.             // ignore
  2679.         }

  2681.         // - GenericProperties
  2682.         try{
  2683.             config.getGenericPropertiesList().addAll(this.genericPropertiesDriver.getGenericProperties());
  2684.         }catch (Exception e) {
  2685.             // ignore
  2686.         }

  2688.         return config;
  2689.     }

  2691.     
  2692.     
  2693.     
  2694.     
  2695.     protected Object getConfigurazioneExtended(Configurazione config, String idExtendedConfiguration) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2696.         Connection con = null;
  2697.         
  2698.         if (this.driver.atomica) {
  2699.             try {
  2700.                 con = this.driver.getConnectionFromDatasource("getConfigurazioneExtended");

  2702.             } catch (Exception e) {
  2703.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getConfigurazioneExtended] Exception accedendo al datasource :" + e.getMessage(),e);

  2705.             }

  2707.         } else
  2708.             con = this.driver.globalConnection;
  2709.         
  2710.         try {
  2711.             
  2712.             this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  2713.             
  2714.             this.driver.logDebug("getConfigurazioneExtended("+idExtendedConfiguration+")");
  2715.             
  2716.             ExtendedInfoManager extInfoManager = ExtendedInfoManager.getInstance();
  2717.             IExtendedInfo extInfoConfigurazioneDriver = extInfoManager.newInstanceExtendedInfoConfigurazione();
  2718.             if(extInfoConfigurazioneDriver!=null){
  2719.                 
  2720.                 Object o = extInfoConfigurazioneDriver.getExtendedInfo(con, this.driver.log, config, idExtendedConfiguration);
  2721.                 if(o==null){
  2722.                     throw new DriverConfigurazioneNotFound("Oggetto non esistente");
  2723.                 }
  2724.                 return o;
  2725.                 
  2726.             }   
  2727.             
  2728.             throw new DriverConfigurazioneException("Driver non inizializzato");

  2730.         } 
  2731.         catch (DriverConfigurazioneNotFound dNot) {
  2732.             throw dNot;
  2733.         }
  2734.         catch (Exception qe) {
  2735.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getConfigurazioneExtended] Errore: " + qe.getMessage(),qe);
  2736.         } 
  2737.         finally {
  2738.             
  2739.             this.driver.closeConnection(con);
  2740.         }
  2741.     }
  2742.     


  2745.     protected void createConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException {
  2746.         Connection con = null;
  2747.         boolean error = false;

  2749.         if (this.driver.atomica) {
  2750.             try {
  2751.                 con = this.driver.getConnectionFromDatasource("createConfigurazione");
  2752.                 con.setAutoCommit(false);
  2753.             } catch (Exception e) {
  2754.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createConfigurazioneGenerale] Exception accedendo al datasource :" + e.getMessage(),e);

  2756.             }

  2758.         } else
  2759.             con = this.driver.globalConnection;

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

  2763.         try {
  2764.             this.driver.logDebug("CRUDConfigurazioneGenerale type = 1");
  2765.             DriverConfigurazioneDB_configLIB.CRUDConfigurazioneGenerale(1, configurazione, con);

  2767.         } catch (Exception qe) {
  2768.             error = true;
  2769.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createConfigurazioneGenerale] Errore durante la create ConfigurazioneGenerale : " + qe.getMessage(),qe);
  2770.         } finally {

  2772.             this.driver.closeConnection(error,con);
  2773.         }
  2774.     }

  2776.     
  2777.     protected void updateConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException {
  2778.         Connection con = null;
  2779.         boolean error = false;

  2781.         if (this.driver.atomica) {
  2782.             try {
  2783.                 con = this.driver.getConnectionFromDatasource("updateConfigurazione");
  2784.                 con.setAutoCommit(false);
  2785.             } catch (Exception e) {
  2786.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateConfigurazioneGenerale] Exception accedendo al datasource :" + e.getMessage(),e);

  2788.             }

  2790.         } else
  2791.             con = this.driver.globalConnection;

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

  2795.         try {
  2796.             this.driver.logDebug("CRUDConfigurazioneGenerale type = 2");
  2797.             DriverConfigurazioneDB_configLIB.CRUDConfigurazioneGenerale(2, configurazione, con);

  2799.         } catch (Exception qe) {
  2800.             error = true;
  2801.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateConfigurazioneGenerale] Errore durante la update ConfigurazioneGenerale : " + qe.getMessage(),qe);
  2802.         } finally {

  2804.             this.driver.closeConnection(error,con);
  2805.         }
  2806.     }

  2808.     
  2809.     protected void deleteConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException {
  2810.         Connection con = null;
  2811.         boolean error = false;

  2813.         if (this.driver.atomica) {
  2814.             try {
  2815.                 con = this.driver.getConnectionFromDatasource("deleteConfigurazione");
  2816.                 con.setAutoCommit(false);
  2817.             } catch (Exception e) {
  2818.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteConfigurazioneGenerale] Exception accedendo al datasource :" + e.getMessage(),e);

  2820.             }

  2822.         } else
  2823.             con = this.driver.globalConnection;

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

  2827.         try {
  2828.             this.driver.logDebug("CRUDConfigurazioneGenerale type = 3");
  2829.             DriverConfigurazioneDB_configLIB.CRUDConfigurazioneGenerale(CostantiDB.DELETE, configurazione, con);

  2831.         } catch (Exception qe) {
  2832.             error = true;
  2833.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteConfigurazioneGenerale] Errore durante la delete ConfigurazioneGenerale : " + qe.getMessage(),qe);
  2834.         } finally {

  2836.             this.driver.closeConnection(error,con);
  2837.         }
  2838.     }
  2839.     

  2841.     // ACCESSO REGISTRO

  2843.     /**
  2844.      * Crea le informazioni per l'accesso ai registri
  2845.      * 
  2846.      * @param registro
  2847.      * @throws DriverConfigurazioneException
  2848.      */

  2850.     protected void createAccessoRegistro(AccessoRegistro registro) throws DriverConfigurazioneException {
  2851.         Connection con = null;
  2852.         boolean error = false;

  2854.         if (this.driver.atomica) {
  2855.             try {
  2856.                 con = this.driver.getConnectionFromDatasource("createAccessoRegistro");
  2857.                 con.setAutoCommit(false);
  2858.             } catch (Exception e) {
  2859.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoRegistro] Exception accedendo al datasource :" + e.getMessage(),e);

  2861.             }

  2863.         } else
  2864.             con = this.driver.globalConnection;

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

  2868.         try {
  2869.             this.driver.logDebug("CRUDAccessoRegistro type = 1");
  2870.             DriverConfigurazioneDB_configLIB.CRUDAccessoRegistro(1, registro, con);

  2872.         } catch (Exception qe) {
  2873.             error = true;
  2874.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoRegistro] Errore durante la updateAccessoRegistro : " + qe.getMessage(),qe);
  2875.         } finally {

  2877.             this.driver.closeConnection(error,con);
  2878.         }
  2879.     }

  2881.     /**
  2882.      * Aggiorna le informazioni per l'accesso ai registri
  2883.      * 
  2884.      * @param registro
  2885.      * @throws DriverConfigurazioneException
  2886.      */
  2887.     protected void updateAccessoRegistro(AccessoRegistro registro) throws DriverConfigurazioneException {
  2888.         Connection con = null;
  2889.         boolean error = false;

  2891.         if (this.driver.atomica) {
  2892.             try {
  2893.                 con = this.driver.getConnectionFromDatasource("updateAccessoRegistro");
  2894.                 con.setAutoCommit(false);
  2895.             } catch (Exception e) {
  2896.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateAccessoRegistro] Exception accedendo al datasource :" + e.getMessage(),e);

  2898.             }

  2900.         } else
  2901.             con = this.driver.globalConnection;

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

  2905.         try {
  2906.             this.driver.logDebug("CRUDAccessoRegistro type = 2");
  2907.             DriverConfigurazioneDB_configLIB.CRUDAccessoRegistro(2, registro, con);

  2909.         } catch (Exception qe) {
  2910.             error = true;
  2911.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateAccessoRegistro] Errore durante la updateAccessoRegistro : " + qe.getMessage(),qe);
  2912.         } finally {

  2914.             this.driver.closeConnection(error,con);
  2915.         }
  2916.     }

  2918.     /**
  2919.      * Elimina le informazioni per l'accesso ai registri
  2920.      * 
  2921.      * @param registro
  2922.      * @throws DriverConfigurazioneException
  2923.      */
  2924.     protected void deleteAccessoRegistro(AccessoRegistro registro) throws DriverConfigurazioneException {
  2925.         Connection con = null;
  2926.         boolean error = false;

  2928.         if (this.driver.atomica) {
  2929.             try {
  2930.                 con = this.driver.getConnectionFromDatasource("deleteAccessoRegistro");
  2931.                 con.setAutoCommit(false);
  2932.             } catch (Exception e) {
  2933.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteAccessoRegistro] Exception accedendo al datasource :" + e.getMessage(),e);

  2935.             }

  2937.         } else
  2938.             con = this.driver.globalConnection;

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

  2942.         try {
  2943.             this.driver.logDebug("CRUDAccessoRegistro type = 3");
  2944.             DriverConfigurazioneDB_configLIB.CRUDAccessoRegistro(3, registro, con);

  2946.         } catch (Exception qe) {
  2947.             error = true;
  2948.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteAccessoRegistro] Errore durante la updateAccessoRegistro : " + qe.getMessage(),qe);
  2949.         } finally {

  2951.             this.driver.closeConnection(error,con);
  2952.         }
  2953.     }
  2954.     
  2955.     protected boolean existsResponseCachingConfigurazioneRegola(Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException {
  2956.         String nomeMetodo = "existsResponseCachingConfigurazioneRegola";

  2958.         Connection con = null;
  2959.         PreparedStatement stmt=null;
  2960.         ResultSet risultato=null;
  2961.         String queryString;

  2963.         if (this.driver.atomica) {
  2964.             try {
  2965.                 con = this.driver.getConnectionFromDatasource("existsResponseCachingConfigurazioneRegola");
  2966.             } catch (Exception e) {
  2967.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2969.             }

  2971.         } else
  2972.             con = this.driver.globalConnection;

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

  2976.         try {

  2978.             int count = 0;
  2979.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2980.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CACHE_REGOLE);
  2981.             sqlQueryObject.addSelectCountField("*", "cont");
  2982.             sqlQueryObject.setANDLogicOperator(true);
  2983.             
  2984.             if(statusMin != null) {
  2985.                 sqlQueryObject.addWhereCondition("status_min = ?");
  2986.             } else {
  2987.                 sqlQueryObject.addWhereIsNullCondition("status_min");
  2988.             }
  2989.             
  2990.             if(statusMax != null) {
  2991.                 sqlQueryObject.addWhereCondition("status_max = ?");
  2992.             } else {
  2993.                 sqlQueryObject.addWhereIsNullCondition("status_max");
  2994.             }
  2995.             
  2996.             //if(fault) {
  2997.             //  sqlQueryObject.addWhereCondition("fault = ?");
  2998.             //} else {
  2999.             sqlQueryObject.addWhereCondition("fault = ?");
  3000.             //}
  3001.             
  3002.             queryString = sqlQueryObject.createSQLQuery();
  3003.             stmt = con.prepareStatement(queryString);
  3004.             int parameterIndex = 1;
  3005.             if(statusMin != null)
  3006.                 stmt.setInt(parameterIndex ++, statusMin);
  3007.             if(statusMax != null)
  3008.                 stmt.setInt(parameterIndex ++, statusMax);
  3009.             if(fault) {
  3010.                 stmt.setInt(parameterIndex ++, CostantiDB.TRUE);
  3011.             } else {
  3012.                 stmt.setInt(parameterIndex ++, CostantiDB.FALSE);
  3013.             }
  3014.             
  3015.             risultato = stmt.executeQuery();
  3016.             if (risultato.next())
  3017.                 count = risultato.getInt(1);
  3018.             risultato.close();
  3019.             stmt.close();

  3021.             return count > 0;

  3023.         } catch (Exception qe) {
  3024.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3025.         } finally {

  3027.             //Chiudo statement and resultset
  3028.             JDBCUtilities.closeResources(risultato, stmt);

  3030.             this.driver.closeConnection(con);
  3031.         }
  3032.     }
  3033.     
  3034.     protected boolean existsProxyPassConfigurazioneRegola(String nome) throws DriverConfigurazioneException {
  3035.         String nomeMetodo = "existsResponseCachingConfigurazioneRegola";

  3037.         Connection con = null;
  3038.         PreparedStatement stmt=null;
  3039.         ResultSet risultato=null;
  3040.         String queryString;

  3042.         if (this.driver.atomica) {
  3043.             try {
  3044.                 con = this.driver.getConnectionFromDatasource("existsResponseCachingConfigurazioneRegola");
  3045.             } catch (Exception e) {
  3046.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3048.             }

  3050.         } else
  3051.             con = this.driver.globalConnection;

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

  3055.         try {

  3057.             int count = 0;
  3058.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3059.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  3060.             sqlQueryObject.addSelectCountField("*", "cont");
  3061.             sqlQueryObject.setANDLogicOperator(true);
  3062.             sqlQueryObject.addWhereCondition("nome = ?");
  3063.             
  3064.             queryString = sqlQueryObject.createSQLQuery();
  3065.             stmt = con.prepareStatement(queryString);
  3066.             int parameterIndex = 1;
  3067.             stmt.setString(parameterIndex ++, nome);
  3068.             
  3069.             risultato = stmt.executeQuery();
  3070.             if (risultato.next())
  3071.                 count = risultato.getInt(1);
  3072.             risultato.close();
  3073.             stmt.close();

  3075.             return count > 0;

  3077.         } catch (Exception qe) {
  3078.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3079.         } finally {

  3081.             //Chiudo statement and resultset
  3082.             JDBCUtilities.closeResources(risultato, stmt);

  3084.             this.driver.closeConnection(con);
  3085.         }
  3086.     }
  3087.     
  3088.     protected boolean existsCanale(String nome) throws DriverConfigurazioneException {
  3089.         String nomeMetodo = "existsCanale";

  3091.         Connection con = null;
  3092.         PreparedStatement stmt=null;
  3093.         ResultSet risultato=null;
  3094.         String queryString;

  3096.         if (this.driver.atomica) {
  3097.             try {
  3098.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  3099.             } catch (Exception e) {
  3100.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3102.             }

  3104.         } else
  3105.             con = this.driver.globalConnection;

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

  3109.         try {

  3111.             int count = 0;
  3112.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3113.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CANALI);
  3114.             sqlQueryObject.addSelectCountField("*", "cont");
  3115.             sqlQueryObject.setANDLogicOperator(true);
  3116.             sqlQueryObject.addWhereCondition("nome = ?");
  3117.             
  3118.             queryString = sqlQueryObject.createSQLQuery();
  3119.             stmt = con.prepareStatement(queryString);
  3120.             int parameterIndex = 1;
  3121.             stmt.setString(parameterIndex ++, nome);
  3122.             
  3123.             risultato = stmt.executeQuery();
  3124.             if (risultato.next())
  3125.                 count = risultato.getInt(1);
  3126.             risultato.close();
  3127.             stmt.close();

  3129.             return count > 0;

  3131.         } catch (Exception qe) {
  3132.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3133.         } finally {

  3135.             //Chiudo statement and resultset
  3136.             JDBCUtilities.closeResources(risultato, stmt);

  3138.             this.driver.closeConnection(con);
  3139.         }
  3140.     }
  3141.     
  3142.     protected boolean existsCanaleNodo(String nome) throws DriverConfigurazioneException {
  3143.         String nomeMetodo = "existsCanaleNodo";

  3145.         Connection con = null;
  3146.         PreparedStatement stmt=null;
  3147.         ResultSet risultato=null;
  3148.         String queryString;

  3150.         if (this.driver.atomica) {
  3151.             try {
  3152.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  3153.             } catch (Exception e) {
  3154.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3156.             }

  3158.         } else
  3159.             con = this.driver.globalConnection;

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

  3163.         try {

  3165.             int count = 0;
  3166.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3167.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CANALI_NODI);
  3168.             sqlQueryObject.addSelectCountField("*", "cont");
  3169.             sqlQueryObject.setANDLogicOperator(true);
  3170.             sqlQueryObject.addWhereCondition("nome = ?");
  3171.             
  3172.             queryString = sqlQueryObject.createSQLQuery();
  3173.             stmt = con.prepareStatement(queryString);
  3174.             int parameterIndex = 1;
  3175.             stmt.setString(parameterIndex ++, nome);
  3176.             
  3177.             risultato = stmt.executeQuery();
  3178.             if (risultato.next())
  3179.                 count = risultato.getInt(1);
  3180.             risultato.close();
  3181.             stmt.close();

  3183.             return count > 0;

  3185.         } catch (Exception qe) {
  3186.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3187.         } finally {

  3189.             //Chiudo statement and resultset
  3190.             JDBCUtilities.closeResources(risultato, stmt);

  3192.             this.driver.closeConnection(con);
  3193.         }
  3194.     }
  3195.     
  3196.     /**
  3197.      * Restituisce la configurazione dei canali
  3198.      * 
  3199.      * @return Configurazione
  3200.      * 
  3201.      */
  3202.     protected CanaliConfigurazione getCanaliConfigurazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  3203.         return this.getCanaliConfigurazione(true);
  3204.     }
  3205.     protected CanaliConfigurazione getCanaliConfigurazione(boolean readNodi) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  3206.     
  3207.         // ritorna la configurazione generale della PdD

  3209.         Connection con = null;
  3210.         PreparedStatement stm = null;
  3211.         ResultSet rs = null;
  3212.         PreparedStatement stm1 = null;
  3213.         ResultSet rs1 = null;
  3214.         PreparedStatement stm2 = null;
  3215.         ResultSet rs2 = null;

  3217.         String sqlQuery = "";

  3219.         if (this.driver.atomica) {
  3220.             try {
  3221.                 con = this.driver.getConnectionFromDatasource("getCanaliConfigurazione");

  3223.             } catch (Exception e) {
  3224.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getCanaliConfigurazione] Exception accedendo al datasource :" + e.getMessage(),e);

  3226.             }

  3228.         } else
  3229.             con = this.driver.globalConnection;

  3231.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  3232.         CanaliConfigurazione config = new CanaliConfigurazione();
  3233.         config.setStato(StatoFunzionalita.DISABILITATO);
  3234.         try {
  3235.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3236.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  3237.             sqlQueryObject.addSelectField(CostantiDB.CONFIGURAZIONE + ".canali_stato");
  3238.             sqlQuery = sqlQueryObject.createSQLQuery();

  3240.             this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery));
  3241.             stm = con.prepareStatement(sqlQuery);
  3242.             rs = stm.executeQuery();

  3244.             if (rs.next()) {

  3246.                 // Canali
  3247.                 String canali_stato = rs.getString("canali_stato");
  3248.                 config.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(canali_stato));
  3249.                 if(config.getStato()==null) {
  3250.                     config.setStato(StatoFunzionalita.DISABILITATO);
  3251.                 }
  3252.                 if(StatoFunzionalita.ABILITATO.equals(config.getStato())) {
  3253.                     DriverConfigurazioneDB_canaliLIB.readCanaliConfigurazione(con, config, false);
  3254.                 }
  3255.             } else {
  3256.                 throw new DriverConfigurazioneNotFound("[DriverConfigurazioneDB::getCanaliConfigurazione] Configurazione non presente.");
  3257.             }

  3259.         } catch (DriverConfigurazioneNotFound e) {
  3260.             throw e;
  3261.         }catch (Exception se) {
  3262.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getCanaliConfigurazione] Exception: " + se.getMessage(),se);
  3263.         } finally {
  3264.             //Chiudo statement and resultset
  3265.             JDBCUtilities.closeResources(rs, stm);
  3266.             JDBCUtilities.closeResources(rs1, stm1);
  3267.             JDBCUtilities.closeResources(rs2, stm2);
  3268.             this.driver.closeConnection(con);
  3269.         }
  3270.         return config;
  3271.     }
  3272. }
Created with JaCoCo 0.8.8.202204050719