DriverConfigurazioneDB_configLIB.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 static org.openspcoop2.core.constants.CostantiDB.CREATE;
  23. import static org.openspcoop2.core.constants.CostantiDB.DELETE;
  24. import static org.openspcoop2.core.constants.CostantiDB.UPDATE;

  26. import java.sql.Connection;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.SQLException;
  30. import java.sql.Timestamp;
  31. import java.util.ArrayList;
  32. import java.util.List;

  34. import org.openspcoop2.core.byok.BYOKUtilities;
  35. import org.openspcoop2.core.byok.BYOKWrappedValue;
  36. import org.openspcoop2.core.byok.IDriverBYOK;
  37. import org.openspcoop2.core.commons.DBUtils;
  38. import org.openspcoop2.core.commons.IExtendedInfo;
  39. import org.openspcoop2.core.config.AccessoConfigurazione;
  40. import org.openspcoop2.core.config.AccessoDatiAttributeAuthority;
  41. import org.openspcoop2.core.config.AccessoDatiAutenticazione;
  42. import org.openspcoop2.core.config.AccessoDatiAutorizzazione;
  43. import org.openspcoop2.core.config.AccessoDatiGestioneToken;
  44. import org.openspcoop2.core.config.AccessoDatiKeystore;
  45. import org.openspcoop2.core.config.AccessoDatiRichieste;
  46. import org.openspcoop2.core.config.AccessoRegistro;
  47. import org.openspcoop2.core.config.AccessoRegistroRegistro;
  48. import org.openspcoop2.core.config.Attachments;
  49. import org.openspcoop2.core.config.Cache;
  50. import org.openspcoop2.core.config.CanaliConfigurazione;
  51. import org.openspcoop2.core.config.Configurazione;
  52. import org.openspcoop2.core.config.ConfigurazioneGeneraleHandler;
  53. import org.openspcoop2.core.config.ConfigurazioneMultitenant;
  54. import org.openspcoop2.core.config.ConfigurazioneTracciamentoPorta;
  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.GenericProperties;
  60. import org.openspcoop2.core.config.IndirizzoRisposta;
  61. import org.openspcoop2.core.config.InoltroBusteNonRiscontrate;
  62. import org.openspcoop2.core.config.IntegrationManager;
  63. import org.openspcoop2.core.config.MessaggiDiagnostici;
  64. import org.openspcoop2.core.config.OpenspcoopAppender;
  65. import org.openspcoop2.core.config.OpenspcoopSorgenteDati;
  66. import org.openspcoop2.core.config.Property;
  67. import org.openspcoop2.core.config.ResponseCachingConfigurazioneGenerale;
  68. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  69. import org.openspcoop2.core.config.Risposte;
  70. import org.openspcoop2.core.config.StatoServiziPdd;
  71. import org.openspcoop2.core.config.StatoServiziPddIntegrationManager;
  72. import org.openspcoop2.core.config.StatoServiziPddPortaApplicativa;
  73. import org.openspcoop2.core.config.StatoServiziPddPortaDelegata;
  74. import org.openspcoop2.core.config.SystemProperties;
  75. import org.openspcoop2.core.config.TipoFiltroAbilitazioneServizi;
  76. import org.openspcoop2.core.config.Tracciamento;
  77. import org.openspcoop2.core.config.TracciamentoConfigurazione;
  78. import org.openspcoop2.core.config.TracciamentoConfigurazioneFiletrace;
  79. import org.openspcoop2.core.config.Transazioni;
  80. import org.openspcoop2.core.config.ValidazioneBuste;
  81. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  82. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  83. import org.openspcoop2.core.config.constants.StatoFunzionalitaCacheDigestQueryParameter;
  84. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  85. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  86. import org.openspcoop2.core.constants.CRUDType;
  87. import org.openspcoop2.core.constants.CostantiDB;
  88. import org.openspcoop2.utils.TipiDatabase;
  89. import org.openspcoop2.utils.date.DateManager;
  90. import org.openspcoop2.utils.jdbc.CustomKeyGeneratorObject;
  91. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKey;
  92. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyJDBCType;
  93. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyObject;
  94. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  95. import org.openspcoop2.utils.sql.ISQLQueryObject;
  96. import org.openspcoop2.utils.sql.SQLObjectFactory;
  97. import org.openspcoop2.utils.sql.SQLQueryObjectException;

  99. /**
  100.  * DriverConfigurazioneDB_configLIB
  101.  * 
  102.  * @author Stefano Corallo - corallo@link.it
  103.  * @author $Author$
  104.  * @version $Rev$, $Date$
  105.  */
  106. public class DriverConfigurazioneDB_configLIB {


  109.     public static long CRUDAccessoRegistro(int type, AccessoRegistroRegistro registro, Connection con) throws DriverConfigurazioneException {
  110.         if (registro == null)
  111.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] Il servizio non puo essere NULL");
  112.         PreparedStatement updateStmt = null;
  113.         String updateQuery = "";
  114.         PreparedStatement selectStmt = null;
  115.         String selectQuery = "";
  116.         ResultSet selectRS = null;

  118.         long idRegistro = 0;
  119.         int n = 0;
  120.         String nome = registro.getNome();
  121.         String location = registro.getLocation();
  122.         String tipo = registro.getTipo().toString();
  123.         String user = registro.getUser();
  124.         String password = registro.getPassword();

  126.         try {
  127.             switch (type) {
  128.             case CREATE:
  129.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  130.                 sqlQueryObject.addInsertTable(CostantiDB.REGISTRI);
  131.                 sqlQueryObject.addInsertField("nome", "?");
  132.                 sqlQueryObject.addInsertField("location", "?");
  133.                 sqlQueryObject.addInsertField("tipo", "?");
  134.                 sqlQueryObject.addInsertField("utente", "?");
  135.                 sqlQueryObject.addInsertField("password", "?");
  136.                 updateQuery = sqlQueryObject.createSQLInsert();
  137.                 updateStmt = con.prepareStatement(updateQuery);

  139.                 updateStmt.setString(1, nome);
  140.                 updateStmt.setString(2, location);
  141.                 updateStmt.setString(3, tipo);
  142.                 updateStmt.setString(4, user);
  143.                 updateStmt.setString(5, password);

  145.                 DriverConfigurazioneDBLib.logDebug("eseguo query: " + DBUtils.formatSQLString(updateQuery, nome, location, tipo, user, password));

  147.                 n = updateStmt.executeUpdate();

  149.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  150.                 sqlQueryObject.addFromTable(CostantiDB.REGISTRI);
  151.                 sqlQueryObject.addSelectField("id");
  152.                 sqlQueryObject.addWhereCondition("nome = ?");
  153.                 sqlQueryObject.addWhereCondition("location = ?");
  154.                 sqlQueryObject.setANDLogicOperator(true);
  155.                 selectQuery = sqlQueryObject.createSQLQuery();
  156.                 selectStmt = con.prepareStatement(selectQuery);
  157.                 selectStmt.setString(1, nome);
  158.                 selectStmt.setString(2, location);
  159.                 selectRS = selectStmt.executeQuery();
  160.                 if (selectRS.next()) {
  161.                     idRegistro = selectRS.getLong("id");
  162.                     registro.setId(idRegistro);
  163.                 }

  165.                 break;
  166.             case UPDATE:

  168.                 if (registro.getId() == null || registro.getId() <= 0)
  169.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro(UPDATE)] L'id del Servizio e' necessario.");
  170.                 idRegistro = registro.getId();

  172.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  173.                 sqlQueryObject.addUpdateTable(CostantiDB.ROUTING);
  174.                 sqlQueryObject.addUpdateField("nome", "?");
  175.                 sqlQueryObject.addUpdateField("location", "?");
  176.                 sqlQueryObject.addUpdateField("tipo", "?");
  177.                 sqlQueryObject.addUpdateField("utente", "?");
  178.                 sqlQueryObject.addUpdateField("password", "?");
  179.                 sqlQueryObject.addWhereCondition("id=?");
  180.                 updateQuery = sqlQueryObject.createSQLUpdate();
  181.                 updateStmt = con.prepareStatement(updateQuery);

  183.                 updateStmt.setString(1, registro.getNome());
  184.                 updateStmt.setString(2, registro.getLocation());
  185.                 updateStmt.setString(3, registro.getTipo().toString());
  186.                 updateStmt.setString(4, registro.getUser());
  187.                 updateStmt.setString(5, registro.getPassword());
  188.                 updateStmt.setLong(6, idRegistro);

  190.                 DriverConfigurazioneDBLib.logDebug("eseguo query: " + DBUtils.formatSQLString(updateQuery, nome, location, tipo, user, password, idRegistro));
  191.                 n = updateStmt.executeUpdate();

  193.                 break;
  194.             case DELETE:
  195.                 if (registro.getId() == null || registro.getId() <= 0)
  196.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro(DELETE)] L'id del Servizio e' necessario.");
  197.                 idRegistro = registro.getId();

  199.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  200.                 sqlQueryObject.addDeleteTable(CostantiDB.REGISTRI);
  201.                 sqlQueryObject.addWhereCondition("id=?");
  202.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  203.                 updateStmt = con.prepareStatement(sqlQuery);
  204.                 updateStmt.setLong(1, idRegistro);
  205.                 DriverConfigurazioneDBLib.logDebug("eseguo query: " + DBUtils.formatSQLString(updateQuery, idRegistro));
  206.                 n=updateStmt.executeUpdate();
  207.                 updateStmt.close();

  209.                 break;
  210.             }

  212.             if (type == CostantiDB.CREATE)
  213.                 return idRegistro;
  214.             else
  215.                 return n;

  217.         } catch (SQLException se) {
  218.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] SQLException [" + se.getMessage() + "].",se);
  219.         }catch (Exception se) {
  220.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] Exception [" + se.getMessage() + "].",se);
  221.         } finally {

  223.             JDBCUtilities.closeResources(selectRS, selectStmt);
  224.             JDBCUtilities.closeResources(updateStmt);

  226.         }

  228.     }

  230.     public static long CRUDAccessoRegistro(int type, AccessoRegistro registro, Connection con) throws DriverConfigurazioneException {
  231.         if (registro == null)
  232.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] Il registro non può essere NULL");
  233.         PreparedStatement updateStmt = null;
  234.         String updateQuery = "";
  235.         PreparedStatement selectStmt = null;
  236.         ResultSet selectRS = null;

  238.         long idRegistro = 0;
  239.         int n = 0;
  240.         Cache arc = registro.getCache();
  241.         String statoCache = "disabilitato";
  242.         String dimensionecache = null;
  243.         String algoritmocache = null;
  244.         String idlecache = null;
  245.         String lifecache = null;
  246.         if (arc != null) {
  247.             statoCache = "abilitato";
  248.             dimensionecache = arc.getDimensione();
  249.             if(arc.getAlgoritmo()!=null){
  250.                 algoritmocache = arc.getAlgoritmo().toString();
  251.             }
  252.             idlecache = arc.getItemIdleTime();
  253.             lifecache = arc.getItemLifeSecond();
  254.         }

  256.         try {
  257.             switch (type) {
  258.             case CREATE:
  259.             case UPDATE:

  261.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  262.                 sqlQueryObject.addUpdateTable(CostantiDB.CONFIGURAZIONE);
  263.                 sqlQueryObject.addUpdateField("statocache", "?");
  264.                 sqlQueryObject.addUpdateField("dimensionecache", "?");
  265.                 sqlQueryObject.addUpdateField("algoritmocache", "?");
  266.                 sqlQueryObject.addUpdateField("idlecache", "?");
  267.                 sqlQueryObject.addUpdateField("lifecache", "?");
  268.                 updateQuery = sqlQueryObject.createSQLUpdate();
  269.                 updateStmt = con.prepareStatement(updateQuery);

  271.                 updateStmt.setString(1, statoCache);
  272.                 updateStmt.setString(2, dimensionecache);
  273.                 updateStmt.setString(3, algoritmocache);
  274.                 updateStmt.setString(4, idlecache);
  275.                 updateStmt.setString(5, lifecache);

  277.                 DriverConfigurazioneDBLib.logDebug("eseguo query :" + DBUtils.formatSQLString(updateQuery, statoCache, dimensionecache, algoritmocache, idlecache, lifecache));

  279.                 n = updateStmt.executeUpdate();
  280.                 updateStmt.close();

  282.                 // Elimino i registri e li ricreo
  283.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  284.                 sqlQueryObject.addDeleteTable(CostantiDB.REGISTRI);
  285.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  286.                 updateStmt = con.prepareStatement(sqlQuery);
  287.                 DriverConfigurazioneDBLib.logDebug("eseguo query: " + DBUtils.formatSQLString(updateQuery));
  288.                 int risultato = updateStmt.executeUpdate();
  289.                 DriverConfigurazioneDBLib.logDebug("eseguo query risultato["+risultato+"]: " + DBUtils.formatSQLString(updateQuery));
  290.                 updateStmt.close();

  292.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  293.                 sqlQueryObject.addInsertTable(CostantiDB.REGISTRI);
  294.                 sqlQueryObject.addInsertField("nome", "?");
  295.                 sqlQueryObject.addInsertField("location", "?");
  296.                 sqlQueryObject.addInsertField("tipo", "?");
  297.                 sqlQueryObject.addInsertField("utente", "?");
  298.                 sqlQueryObject.addInsertField("password", "?");
  299.                 updateQuery = sqlQueryObject.createSQLInsert();
  300.                 for (int i = 0; i < registro.sizeRegistroList(); i++) {
  301.                     updateStmt = con.prepareStatement(updateQuery);
  302.                     AccessoRegistroRegistro arr = registro.getRegistro(i);
  303.                     String nome = arr.getNome();
  304.                     String location = arr.getLocation();
  305.                     String tipo = arr.getTipo().toString();
  306.                     String utente = arr.getUser();
  307.                     String password = arr.getPassword();

  309.                     updateStmt.setString(1, nome);
  310.                     updateStmt.setString(2, location);
  311.                     updateStmt.setString(3, tipo);
  312.                     updateStmt.setString(4, utente);
  313.                     updateStmt.setString(5, password);
  314.                     DriverConfigurazioneDBLib.logDebug("eseguo query INSERT INTO " + CostantiDB.REGISTRI + "(nome, location, tipo, utente, password) VALUES ("+
  315.                             nome+", "+location+", "+tipo+", "+utente+", "+password+")");
  316.                     updateStmt.executeUpdate();
  317.                     updateStmt.close();
  318.                 }

  320.                 break;
  321.             case DELETE:
  322.                 // non rimuovo nulla in quanto la tabella configurazione
  323.                 // contiene solo una riga con i valori
  324.                 // che vanno modificati con la update
  325.                 break;
  326.             }

  328.             if (type == CostantiDB.CREATE)
  329.                 return idRegistro;
  330.             else
  331.                 return n;

  333.         } catch (SQLException se) {
  334.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] SQLException [" + se.getMessage() + "].",se);
  335.         }catch (Exception se) {
  336.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] Exception [" + se.getMessage() + "].",se);
  337.         } finally {

  339.             JDBCUtilities.closeResources(selectRS, selectStmt);
  340.             JDBCUtilities.closeResources(updateStmt);
  341.             
  342.         }

  344.     }
  345.     
  346.     
  347.     
  348.     public static long CRUDAccessoConfigurazione(int type, AccessoConfigurazione accessoConfigurazione, Connection con) throws DriverConfigurazioneException {
  349.         if (accessoConfigurazione == null)
  350.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoConfigurazione] Parametro accessoConfigurazione non può essere NULL");
  351.         PreparedStatement updateStmt = null;
  352.         String updateQuery = "";

  354.         int n = 0;
  355.         Cache cache = accessoConfigurazione.getCache();
  356.         String statoCache = "disabilitato";
  357.         String dimensionecache = null;
  358.         String algoritmocache = null;
  359.         String idlecache = null;
  360.         String lifecache = null;
  361.         if (cache != null) {
  362.             statoCache = "abilitato";
  363.             dimensionecache = cache.getDimensione();
  364.             if(cache.getAlgoritmo()!=null){
  365.                 algoritmocache = cache.getAlgoritmo().toString();
  366.             }
  367.             idlecache = cache.getItemIdleTime();
  368.             lifecache = cache.getItemLifeSecond();
  369.         }

  371.         try {
  372.             switch (type) {
  373.             case CREATE:
  374.             case UPDATE:

  376.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  377.                 sqlQueryObject.addUpdateTable(CostantiDB.CONFIGURAZIONE);
  378.                 sqlQueryObject.addUpdateField("config_statocache", "?");
  379.                 sqlQueryObject.addUpdateField("config_dimensionecache", "?");
  380.                 sqlQueryObject.addUpdateField("config_algoritmocache", "?");
  381.                 sqlQueryObject.addUpdateField("config_idlecache", "?");
  382.                 sqlQueryObject.addUpdateField("config_lifecache", "?");
  383.                 updateQuery = sqlQueryObject.createSQLUpdate();
  384.                 updateStmt = con.prepareStatement(updateQuery);

  386.                 updateStmt.setString(1, statoCache);
  387.                 updateStmt.setString(2, dimensionecache);
  388.                 updateStmt.setString(3, algoritmocache);
  389.                 updateStmt.setString(4, idlecache);
  390.                 updateStmt.setString(5, lifecache);

  392.                 DriverConfigurazioneDBLib.logDebug("eseguo query :" + DBUtils.formatSQLString(updateQuery, statoCache, dimensionecache, algoritmocache, idlecache, lifecache));

  394.                 n = updateStmt.executeUpdate();
  395.                 updateStmt.close();

  397.                 break;
  398.             case DELETE:
  399.                 // non rimuovo nulla in quanto la tabella configurazione
  400.                 // contiene solo una riga con i valori
  401.                 // che vanno modificati con la update
  402.                 break;
  403.             }

  405.             return n;

  407.         } catch (SQLException se) {
  408.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoConfigurazione] SQLException [" + se.getMessage() + "].",se);
  409.         }catch (Exception se) {
  410.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoConfigurazione] Exception [" + se.getMessage() + "].",se);
  411.         } finally {
  412.             JDBCUtilities.closeResources(updateStmt);
  413.         }

  415.     }
  416.     
  417.     
  418.     
  419.     public static long CRUDAccessoDatiAutorizzazione(int type, AccessoDatiAutorizzazione accessoDatiAutorizzazione, Connection con) throws DriverConfigurazioneException {
  420.         if (accessoDatiAutorizzazione == null)
  421.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoDatiAutorizzazione] Parametro accessoDatiAutorizzazione non può essere NULL");
  422.         PreparedStatement updateStmt = null;
  423.         String updateQuery = "";

  425.         int n = 0;
  426.         Cache cache = accessoDatiAutorizzazione.getCache();
  427.         String statoCache = "disabilitato";
  428.         String dimensionecache = null;
  429.         String algoritmocache = null;
  430.         String idlecache = null;
  431.         String lifecache = null;
  432.         if (cache != null) {
  433.             statoCache = "abilitato";
  434.             dimensionecache = cache.getDimensione();
  435.             if(cache.getAlgoritmo()!=null){
  436.                 algoritmocache = cache.getAlgoritmo().toString();
  437.             }
  438.             idlecache = cache.getItemIdleTime();
  439.             lifecache = cache.getItemLifeSecond();
  440.         }

  442.         try {
  443.             switch (type) {
  444.             case CREATE:
  445.             case UPDATE:

  447.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  448.                 sqlQueryObject.addUpdateTable(CostantiDB.CONFIGURAZIONE);
  449.                 sqlQueryObject.addUpdateField("auth_statocache", "?");
  450.                 sqlQueryObject.addUpdateField("auth_dimensionecache", "?");
  451.                 sqlQueryObject.addUpdateField("auth_algoritmocache", "?");
  452.                 sqlQueryObject.addUpdateField("auth_idlecache", "?");
  453.                 sqlQueryObject.addUpdateField("auth_lifecache", "?");
  454.                 updateQuery = sqlQueryObject.createSQLUpdate();
  455.                 updateStmt = con.prepareStatement(updateQuery);

  457.                 updateStmt.setString(1, statoCache);
  458.                 updateStmt.setString(2, dimensionecache);
  459.                 updateStmt.setString(3, algoritmocache);
  460.                 updateStmt.setString(4, idlecache);
  461.                 updateStmt.setString(5, lifecache);

  463.                 DriverConfigurazioneDBLib.logDebug("eseguo query :" + DBUtils.formatSQLString(updateQuery, statoCache, dimensionecache, algoritmocache, idlecache, lifecache));

  465.                 n = updateStmt.executeUpdate();
  466.                 updateStmt.close();

  468.                 break;
  469.             case DELETE:
  470.                 // non rimuovo nulla in quanto la tabella configurazione
  471.                 // contiene solo una riga con i valori
  472.                 // che vanno modificati con la update
  473.                 break;
  474.             }

  476.             return n;

  478.         } catch (SQLException se) {
  479.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoDatiAutorizzazione] SQLException [" + se.getMessage() + "].",se);
  480.         }catch (Exception se) {
  481.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoDatiAutorizzazione] Exception [" + se.getMessage() + "].",se);
  482.         } finally {
  483.             JDBCUtilities.closeResources(updateStmt);
  484.         }

  486.     }
  487.     
  488.     
  489.     public static void CRUDServiziPdD(int type, StatoServiziPdd statoServiziPdD, Connection con) throws DriverConfigurazioneException {
  490.         if (statoServiziPdD == null)
  491.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDServiziPdD] Le configurazioni del servizio non possono essere NULL");
  492.         PreparedStatement updateStmt = null;
  493.         String updateQuery = "";
  494.         PreparedStatement selectStmt = null;
  495.         ResultSet selectRS = null;
  496.         

  498.         try {
  499.             switch (type) {
  500.             case CREATE:
  501.             case UPDATE:

  503.                 // Elimino le configurazioni e le ricreo
  504.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  505.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_PDD_FILTRI);
  506.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  507.                 updateStmt = con.prepareStatement(sqlQuery);
  508.                 DriverConfigurazioneDBLib.logDebug("eseguo query: " + DBUtils.formatSQLString(updateQuery));
  509.                 int risultato = updateStmt.executeUpdate();
  510.                 DriverConfigurazioneDBLib.logDebug("eseguo query risultato["+risultato+"]: " + DBUtils.formatSQLString(updateQuery));
  511.                 updateStmt.close();

  513.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  514.                 sqlQueryObject.addDeleteTable(CostantiDB.SERVIZI_PDD);
  515.                 sqlQuery = sqlQueryObject.createSQLDelete();
  516.                 updateStmt = con.prepareStatement(sqlQuery);
  517.                 DriverConfigurazioneDBLib.logDebug("eseguo query: " + DBUtils.formatSQLString(updateQuery));
  518.                 risultato = updateStmt.executeUpdate();
  519.                 DriverConfigurazioneDBLib.logDebug("eseguo query risultato["+risultato+"]: " + DBUtils.formatSQLString(updateQuery));
  520.                 updateStmt.close();
  521.                 
  522.                 // Ricreo
  523.                 if(statoServiziPdD.getPortaDelegata()!=null){
  524.                 
  525.                     StatoServiziPddPortaDelegata sPD = statoServiziPdD.getPortaDelegata();
  526.                     
  527.                     int stato = CostantiDB.TRUE;
  528.                     if(sPD.getStato()!=null){
  529.                         stato = CostantiConfigurazione.DISABILITATO.equals(sPD.getStato()) ? CostantiDB.FALSE : CostantiDB.TRUE;
  530.                     }
  531.                     
  532.                     DriverConfigurazioneDB_configLIB.registraComponentePdD(CostantiDB.COMPONENTE_SERVIZIO_PD, stato, con, sPD.getFiltroAbilitazioneList(), sPD.getFiltroDisabilitazioneList());
  533.                     
  534.                 }
  535.                 if(statoServiziPdD.getPortaApplicativa()!=null){
  536.                     
  537.                     StatoServiziPddPortaApplicativa sPA = statoServiziPdD.getPortaApplicativa();
  538.                     
  539.                     int stato = CostantiDB.TRUE;
  540.                     if(sPA.getStato()!=null){
  541.                         stato = CostantiConfigurazione.DISABILITATO.equals(sPA.getStato()) ? CostantiDB.FALSE : CostantiDB.TRUE;
  542.                     }
  543.                     
  544.                     DriverConfigurazioneDB_configLIB.registraComponentePdD(CostantiDB.COMPONENTE_SERVIZIO_PA, stato, con, sPA.getFiltroAbilitazioneList(), sPA.getFiltroDisabilitazioneList());
  545.                     
  546.                 }
  547.                 if(statoServiziPdD.getIntegrationManager()!=null){
  548.                     
  549.                     StatoServiziPddIntegrationManager sIM = statoServiziPdD.getIntegrationManager();
  550.                     
  551.                     int stato = CostantiDB.TRUE;
  552.                     if(sIM.getStato()!=null){
  553.                         stato = CostantiConfigurazione.DISABILITATO.equals(sIM.getStato()) ? CostantiDB.FALSE : CostantiDB.TRUE;
  554.                     }
  555.                     
  556.                     DriverConfigurazioneDB_configLIB.registraComponentePdD(CostantiDB.COMPONENTE_SERVIZIO_IM, stato, con, null, null);
  557.                     
  558.                 }
  559.                 

  561.                 break;
  562.             case DELETE:
  563.                 // non rimuovo nulla in quanto la tabella configurazione
  564.                 // contiene solo una riga con i valori
  565.                 // che vanno modificati con la update
  566.                 break;
  567.             }


  570.         } catch (SQLException se) {
  571.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] SQLException [" + se.getMessage() + "].",se);
  572.         }catch (Exception se) {
  573.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] Exception [" + se.getMessage() + "].",se);
  574.         } finally {

  576.             JDBCUtilities.closeResources(selectRS, selectStmt);
  577.             JDBCUtilities.closeResources(updateStmt);
  578.             
  579.         }

  581.     }

  583.     private static void registraComponentePdD(String componente,int stato,Connection con,
  584.             List<TipoFiltroAbilitazioneServizi> abilitazioni,
  585.             List<TipoFiltroAbilitazioneServizi> disabilitazioni) throws Exception{
  586.         PreparedStatement updateStmt = null;
  587.         String updateQuery = "";
  588.         PreparedStatement selectStmt = null;
  589.         ResultSet selectRS = null;
  590.         

  592.         try {
  593.             
  594.             // registro componente
  595.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  596.             sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_PDD);
  597.             sqlQueryObject.addInsertField("componente", "?");
  598.             sqlQueryObject.addInsertField("stato", "?");
  599.             updateQuery = sqlQueryObject.createSQLInsert();
  600.             updateStmt = con.prepareStatement(updateQuery);
  601.             DriverConfigurazioneDBLib.logDebug("eseguo query INSERT INTO " + CostantiDB.SERVIZI_PDD + "(componente, stato) VALUES ('"+
  602.                     componente+"', "+stato+")");
  603.             updateStmt.setString(1, componente);
  604.             updateStmt.setInt(2, stato);
  605.             updateStmt.executeUpdate();
  606.             updateStmt.close();
  607.             
  608.             // recuper id del componente
  609.             long idComponente = -1;
  610.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  611.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_PDD);
  612.             sqlQueryObject.addSelectField("id");
  613.             sqlQueryObject.addWhereCondition("componente=?");
  614.             updateQuery = sqlQueryObject.createSQLQuery();
  615.             selectStmt = con.prepareStatement(updateQuery);
  616.             DriverConfigurazioneDBLib.logDebug("eseguo query ["+updateQuery+"] per il componente ["+componente+"]");
  617.             selectStmt.setString(1, componente);
  618.             selectRS = selectStmt.executeQuery();
  619.             if(selectRS.next()){
  620.                 idComponente = selectRS.getLong("id");
  621.             }else{
  622.                 throw new Exception("Query ["+updateQuery+"] per il componente ["+componente+"] non ha ritornato risultati");
  623.             }
  624.             selectRS.close();
  625.             selectStmt.close();
  626.             
  627.             // registro i filtri
  628.             
  629.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  630.             sqlQueryObject.addInsertTable(CostantiDB.SERVIZI_PDD_FILTRI);
  631.             sqlQueryObject.addInsertField("id_servizio_pdd", "?");
  632.             sqlQueryObject.addInsertField("tipo_filtro", "?");
  633.             sqlQueryObject.addInsertField("tipo_soggetto_fruitore", "?");
  634.             sqlQueryObject.addInsertField("soggetto_fruitore", "?");
  635.             sqlQueryObject.addInsertField("identificativo_porta_fruitore", "?");
  636.             sqlQueryObject.addInsertField("tipo_soggetto_erogatore", "?");
  637.             sqlQueryObject.addInsertField("soggetto_erogatore", "?");
  638.             sqlQueryObject.addInsertField("identificativo_porta_erogatore", "?");
  639.             sqlQueryObject.addInsertField("tipo_servizio", "?");
  640.             sqlQueryObject.addInsertField("servizio", "?");
  641.             sqlQueryObject.addInsertField("versione_servizio", "?");
  642.             sqlQueryObject.addInsertField("azione", "?");
  643.             updateQuery = sqlQueryObject.createSQLInsert();
  644.             
  645.             if(abilitazioni!=null){
  646.                 for (TipoFiltroAbilitazioneServizi filtro : abilitazioni) {
  647.             
  648.                     updateStmt = con.prepareStatement(updateQuery);
  649.                     int index = 1;
  650.                     
  651.                     updateStmt.setLong(index++, idComponente);
  652.                     updateStmt.setString(index++,CostantiDB.TIPO_FILTRO_ABILITAZIONE_SERVIZIO_PDD);
  653.                     
  654.                     updateStmt.setString(index++,filtro.getTipoSoggettoFruitore());
  655.                     updateStmt.setString(index++,filtro.getSoggettoFruitore());
  656.                     updateStmt.setString(index++,filtro.getIdentificativoPortaFruitore());
  657.                     
  658.                     updateStmt.setString(index++,filtro.getTipoSoggettoErogatore());
  659.                     updateStmt.setString(index++,filtro.getSoggettoErogatore());
  660.                     updateStmt.setString(index++,filtro.getIdentificativoPortaErogatore());
  661.                     
  662.                     updateStmt.setString(index++,filtro.getTipoServizio());
  663.                     updateStmt.setString(index++,filtro.getServizio());
  664.                     if(filtro.getVersioneServizio()!=null){
  665.                         updateStmt.setInt(index++,filtro.getVersioneServizio());
  666.                     }
  667.                     else{
  668.                         updateStmt.setNull(index++, java.sql.Types.INTEGER);
  669.                     }
  670.                     
  671.                     updateStmt.setString(index++,filtro.getAzione());
  672.                     
  673.                     updateStmt.executeUpdate();
  674.                     updateStmt.close();
  675.                     
  676.                 }
  677.             }
  678.             
  679.             if(disabilitazioni!=null){
  680.                 for (TipoFiltroAbilitazioneServizi filtro : disabilitazioni) {
  681.             
  682.                     updateStmt = con.prepareStatement(updateQuery);
  683.                     int index = 1;
  684.                     
  685.                     updateStmt.setLong(index++, idComponente);
  686.                     updateStmt.setString(index++,CostantiDB.TIPO_FILTRO_DISABILITAZIONE_SERVIZIO_PDD);
  687.                     
  688.                     updateStmt.setString(index++,filtro.getTipoSoggettoFruitore());
  689.                     updateStmt.setString(index++,filtro.getSoggettoFruitore());
  690.                     updateStmt.setString(index++,filtro.getIdentificativoPortaFruitore());
  691.                     
  692.                     updateStmt.setString(index++,filtro.getTipoSoggettoErogatore());
  693.                     updateStmt.setString(index++,filtro.getSoggettoErogatore());
  694.                     updateStmt.setString(index++,filtro.getIdentificativoPortaErogatore());
  695.                     
  696.                     updateStmt.setString(index++,filtro.getTipoServizio());
  697.                     updateStmt.setString(index++,filtro.getServizio());
  698.                     if(filtro.getVersioneServizio()!=null){
  699.                         updateStmt.setInt(index++,filtro.getVersioneServizio());
  700.                     }
  701.                     else{
  702.                         updateStmt.setNull(index++, java.sql.Types.INTEGER);
  703.                     }
  704.                     
  705.                     updateStmt.setString(index++,filtro.getAzione());
  706.                     
  707.                     updateStmt.executeUpdate();
  708.                     updateStmt.close();
  709.                     
  710.                 }
  711.             }
  712.              
  713.         } finally {

  715.             JDBCUtilities.closeResources(selectRS, selectStmt);
  716.             JDBCUtilities.closeResources(updateStmt);
  717.             
  718.         }
  719.     }
  720.     
  721.     
  722.     
  723.     public static void CRUDSystemPropertiesPdD(int type, SystemProperties systemProperties, Connection con, IDriverBYOK driverBYOK) throws DriverConfigurazioneException {
  724.         if (systemProperties == null)
  725.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDSystemPropertiesPdD] Le configurazioni per le system properties non possono essere NULL");
  726.         PreparedStatement updateStmt = null;
  727.         String updateQuery = "";
  728.         PreparedStatement selectStmt = null;
  729.         ResultSet selectRS = null;
  730.         

  732.         try {
  733.             
  734.             // Elimino le configurazioni e le ricreo per insert e update
  735.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  736.             sqlQueryObject.addDeleteTable(CostantiDB.SYSTEM_PROPERTIES_PDD);
  737.             String sqlQuery = sqlQueryObject.createSQLDelete();
  738.             updateStmt = con.prepareStatement(sqlQuery);
  739.             DriverConfigurazioneDBLib.logDebug("eseguo query: " + DBUtils.formatSQLString(updateQuery));
  740.             int risultato = updateStmt.executeUpdate();
  741.             DriverConfigurazioneDBLib.logDebug("eseguo query risultato["+risultato+"]: " + DBUtils.formatSQLString(updateQuery));
  742.             updateStmt.close();
  743.             
  744.             switch (type) {
  745.             case CREATE:
  746.             case UPDATE:
  747.         
  748.                 for (int i = 0; i < systemProperties.sizeSystemPropertyList(); i++) {
  749.                 
  750.                     Property sp = systemProperties.getSystemProperty(i);
  751.                     String nome = sp.getNome();
  752.                     
  753.                     // Riga
  754.                     // registro componente
  755.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  756.                     sqlQueryObject.addInsertTable(CostantiDB.SYSTEM_PROPERTIES_PDD);
  757.                     sqlQueryObject.addInsertField("nome", "?");
  758.                     sqlQueryObject.addInsertField("valore", "?");
  759.                     sqlQueryObject.addInsertField("enc_value", "?");
  760.                     updateQuery = sqlQueryObject.createSQLInsert();
  761.                     updateStmt = con.prepareStatement(updateQuery);

  763.                     int index = 1;
  764.                     updateStmt.setString(index++, nome);
  765.                     
  766.                     String plainValue = sp.getValore();
  767.                     String encValue = null;
  768.                     if(driverBYOK!=null && BYOKUtilities.isWrappedValue(plainValue) ) {
  769.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  770.                         if(byokValue!=null) {
  771.                             encValue = byokValue.getWrappedValue();
  772.                             plainValue = byokValue.getWrappedPlainValue();
  773.                         }
  774.                     }
  775.                     
  776.                     updateStmt.setString(index++, plainValue);
  777.                     updateStmt.setString(index++, encValue);
  778.                     
  779.                     DriverConfigurazioneDBLib.logDebug("eseguo query INSERT INTO " + CostantiDB.SYSTEM_PROPERTIES_PDD + "(nome, valore) VALUES ('"+
  780.                             nome+"', "+plainValue+")");
  781.                     updateStmt.executeUpdate();
  782.                     updateStmt.close();
  783.                     
  784.                     // recuper id del componente
  785.                     long idComponente = -1;
  786.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  787.                     sqlQueryObject.addFromTable(CostantiDB.SYSTEM_PROPERTIES_PDD);
  788.                     sqlQueryObject.addSelectField("id");
  789.                     sqlQueryObject.setANDLogicOperator(true);
  790.                     sqlQueryObject.addWhereCondition("nome=?");
  791.                     sqlQueryObject.addWhereCondition("valore=?");
  792.                     updateQuery = sqlQueryObject.createSQLQuery();
  793.                     selectStmt = con.prepareStatement(updateQuery);
  794.                     DriverConfigurazioneDBLib.logDebug("eseguo query ["+updateQuery+"] per la prop nome["+nome+"] valore["+plainValue+"]");
  795.                     selectStmt.setString(1, nome);
  796.                     selectStmt.setString(2, plainValue);
  797.                     selectRS = selectStmt.executeQuery();
  798.                     if(selectRS.next()){
  799.                         idComponente = selectRS.getLong("id");
  800.                     }else{
  801.                         throw new DriverConfigurazioneException("Query ["+updateQuery+"] per la prop nome["+nome+"] valore["+plainValue+"] non ha ritornato risultati");
  802.                     }
  803.                     selectRS.close();
  804.                     selectStmt.close();
  805.                     
  806.                     sp.setId(idComponente);
  807.                 }

  809.                 break;
  810.             case DELETE:
  811.                 // non rimuovo in quanto gia fatto sopra.
  812.                 break;
  813.             }


  816.         } catch (SQLException se) {
  817.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] SQLException [" + se.getMessage() + "].",se);
  818.         }catch (Exception se) {
  819.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDAccessoRegistro] Exception [" + se.getMessage() + "].",se);
  820.         } finally {

  822.             JDBCUtilities.closeResources(selectRS, selectStmt);
  823.             JDBCUtilities.closeResources(updateStmt);
  824.             
  825.         }

  827.     }
  828.     
  829.     
  830.     
  831.     
  832.     public static void CRUDGenericProperties(int type, GenericProperties genericProperties, Connection con, IDriverBYOK driverBYOK) throws DriverConfigurazioneException {
  833.         if (genericProperties == null)
  834.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDGenericProperties] Le configurazioni per le generic properties non possono essere NULL");
  835.         PreparedStatement updateStmt = null;
  836.         String updateQuery = "";
  837.         PreparedStatement selectStmt = null;
  838.         ResultSet selectRS = null;
  839.         

  841.         try {
  842.             
  843.             if(genericProperties.getNome()==null) {
  844.                 throw new DriverConfigurazioneException("Nome non fornito");
  845.             }
  846.             if(genericProperties.getTipologia()==null) {
  847.                 throw new DriverConfigurazioneException("Tipologia non fornita");
  848.             }
  849.             
  850.             // Recupero id generic properties
  851.             long idParent = -1;
  852.             if(type == CostantiDB.UPDATE || type == CostantiDB.DELETE) {
  853.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  854.                 sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTIES);
  855.                 sqlQueryObject.addSelectField("*");
  856.                 sqlQueryObject.addWhereCondition("nome=?");
  857.                 sqlQueryObject.addWhereCondition("tipologia=?");
  858.                 sqlQueryObject.setANDLogicOperator(true);
  859.                 String sqlQuery = sqlQueryObject.createSQLQuery();
  860.                 selectStmt = con.prepareStatement(sqlQuery);
  861.                 selectStmt.setString(1, genericProperties.getNome());
  862.                 selectStmt.setString(2, genericProperties.getTipologia());
  863.                 selectRS = selectStmt.executeQuery();
  864.                 
  865.                 if(selectRS.next()) {
  866.                     idParent = selectRS.getLong("id");
  867.                 }
  868.                 selectRS.close();
  869.                 selectStmt.close();
  870.                 
  871.                 if(idParent<=0) {
  872.                     throw new DriverConfigurazioneException("Configuration Property non trovato con nome ["+genericProperties.getNome()+"] e tipologia ["+genericProperties.getTipologia()+"]");
  873.                 }
  874.                 
  875.                 // Elimino anche le configurazioni (nell'update le ricreo)
  876.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  877.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_GENERIC_PROPERTY);
  878.                 sqlQueryObject.addWhereCondition("id_props=?");
  879.                 sqlQueryObject.setANDLogicOperator(true);
  880.                 updateQuery = sqlQueryObject.createSQLDelete();
  881.                 updateStmt = con.prepareStatement(updateQuery);
  882.                 updateStmt.setLong(1, idParent);
  883.                 updateStmt.executeUpdate();
  884.                 updateStmt.close();

  886.                 // delete
  887.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  888.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_GENERIC_PROPERTIES);
  889.                 sqlQueryObject.addWhereCondition("id=?");
  890.                 updateQuery = sqlQueryObject.createSQLDelete();
  891.                 updateStmt = con.prepareStatement(updateQuery);
  892.                 updateStmt.setLong(1, idParent);
  893.                 updateStmt.executeUpdate();
  894.                 updateStmt.close();
  895.             }

  897.             String utenteRichiedente = null;
  898.             Timestamp dataCreazione = null;
  899.             if(type == CostantiDB.CREATE || type == CostantiDB.UPDATE) {
  900.                 if(genericProperties.getProprietaOggetto()!=null && genericProperties.getProprietaOggetto().getUtenteRichiedente()!=null) {
  901.                     utenteRichiedente = genericProperties.getProprietaOggetto().getUtenteRichiedente();
  902.                 }
  903.                 
  904.                 if(genericProperties.getProprietaOggetto()!=null && genericProperties.getProprietaOggetto().getDataCreazione()!=null) {
  905.                     dataCreazione = new Timestamp(genericProperties.getProprietaOggetto().getDataCreazione().getTime());
  906.                 }
  907.                 else {
  908.                     dataCreazione = DateManager.getTimestamp();
  909.                 }
  910.             }
  911.             
  912.             String utenteUltimaModifica = null;
  913.             Timestamp dataUltimaModifica = null;
  914.             if(type == CostantiDB.UPDATE) {
  915.                 if(genericProperties.getProprietaOggetto()!=null && genericProperties.getProprietaOggetto().getUtenteUltimaModifica()!=null) {
  916.                     utenteUltimaModifica = genericProperties.getProprietaOggetto().getUtenteUltimaModifica();
  917.                 }
  918.                 
  919.                 if(genericProperties.getProprietaOggetto()!=null && genericProperties.getProprietaOggetto().getDataUltimaModifica()!=null) {
  920.                     dataUltimaModifica = new Timestamp(genericProperties.getProprietaOggetto().getDataUltimaModifica().getTime());
  921.                 }
  922.                 else {
  923.                     dataUltimaModifica = DateManager.getTimestamp();
  924.                 }
  925.             }

  927.             switch (type) {
  928.             case CREATE:
  929.             case UPDATE:
  930.         
  931.                 // insert

  933.                 List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  934.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome", genericProperties.getNome() , InsertAndGeneratedKeyJDBCType.STRING) );
  935.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("descrizione", genericProperties.getDescrizione() , InsertAndGeneratedKeyJDBCType.STRING) );
  936.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipologia", genericProperties.getTipologia() , InsertAndGeneratedKeyJDBCType.STRING) );
  937.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo", genericProperties.getTipo() , InsertAndGeneratedKeyJDBCType.STRING) );
  938.                 
  939.                 if(type == CostantiDB.CREATE || type == CostantiDB.UPDATE) {
  940.                     if(utenteRichiedente!=null) {
  941.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE, utenteRichiedente , InsertAndGeneratedKeyJDBCType.STRING) );
  942.                     }
  943.                     if(dataCreazione!=null) {
  944.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE, dataCreazione , InsertAndGeneratedKeyJDBCType.TIMESTAMP) );
  945.                     }
  946.                 }
  947.                 if(type == CostantiDB.UPDATE) {
  948.                     if(utenteUltimaModifica!=null) {
  949.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, utenteUltimaModifica , InsertAndGeneratedKeyJDBCType.STRING) );
  950.                     }
  951.                     if(dataUltimaModifica!=null) {
  952.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, dataUltimaModifica , InsertAndGeneratedKeyJDBCType.TIMESTAMP) );
  953.                     }
  954.                 }
  955.                 
  956.                 long idProperties = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  957.                         new CustomKeyGeneratorObject(CostantiDB.CONFIG_GENERIC_PROPERTIES, CostantiDB.CONFIG_GENERIC_PROPERTIES_COLUMN_ID, 
  958.                                 CostantiDB.CONFIG_GENERIC_PROPERTIES_SEQUENCE, CostantiDB.CONFIG_GENERIC_PROPERTIES_TABLE_FOR_ID),
  959.                         listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  960.                 if(idProperties<=0){
  961.                     throw new DriverConfigurazioneException("ID (Generic Properties) autoincrementale non ottenuto");
  962.                 }

  964.                 for(int l=0; l<genericProperties.sizePropertyList();l++){
  965.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  966.                     sqlQueryObject.addInsertTable(CostantiDB.CONFIG_GENERIC_PROPERTY);
  967.                     sqlQueryObject.addInsertField("id_props", "?");
  968.                     sqlQueryObject.addInsertField("nome", "?");
  969.                     sqlQueryObject.addInsertField("valore", "?");
  970.                     sqlQueryObject.addInsertField("enc_value", "?");
  971.                     updateQuery = sqlQueryObject.createSQLInsert();
  972.                     updateStmt = con.prepareStatement(updateQuery);
  973.                     int index = 1;
  974.                     updateStmt.setLong(index++, idProperties);
  975.                     updateStmt.setString(index++, genericProperties.getProperty(l).getNome());
  976.                     
  977.                     String plainValue = genericProperties.getProperty(l).getValore();
  978.                     String encValue = null;
  979.                     if(driverBYOK!=null && DriverConfigurazioneDB_genericPropertiesDriver.isConfidentialProperty(genericProperties.getTipo(), genericProperties.getProperty(l).getNome())) {
  980.                         BYOKWrappedValue byokValue = driverBYOK.wrap(plainValue);
  981.                         if(byokValue!=null) {
  982.                             encValue = byokValue.getWrappedValue();
  983.                             plainValue = byokValue.getWrappedPlainValue();
  984.                         }
  985.                     }
  986.                     
  987.                     updateStmt.setString(index++, plainValue);
  988.                     updateStmt.setString(index++, encValue);
  989.                     
  990.                     updateStmt.executeUpdate();
  991.                     updateStmt.close();
  992.                 }

  994.                 break;
  995.             case DELETE:
  996.                 // non rimuovo in quanto gia fatto sopra.
  997.                 break;
  998.             }


  1001.         } catch (SQLException se) {
  1002.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDGenericProperties] SQLException [" + se.getMessage() + "].",se);
  1003.         }catch (Exception se) {
  1004.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDGenericProperties] Exception [" + se.getMessage() + "].",se);
  1005.         } finally {

  1007.             JDBCUtilities.closeResources(selectRS, selectStmt);
  1008.             JDBCUtilities.closeResources(updateStmt);
  1009.             
  1010.         }

  1012.     }
  1013.     

  1015.     private static void createUrlInvocazioneRegolaEngine(ConfigurazioneUrlInvocazioneRegola regola, Connection con) throws SQLQueryObjectException, SQLException {
  1016.         PreparedStatement updateStmt = null;
  1017.         

  1019.         try {
  1020.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1021.             sqlQueryObject.addInsertTable(CostantiDB.CONFIG_URL_REGOLE);
  1022.             sqlQueryObject.addInsertField("nome", "?");
  1023.             sqlQueryObject.addInsertField("posizione", "?");
  1024.             sqlQueryObject.addInsertField("stato", "?");
  1025.             sqlQueryObject.addInsertField("descrizione", "?");
  1026.             sqlQueryObject.addInsertField("regexpr", "?");
  1027.             sqlQueryObject.addInsertField("regola", "?");
  1028.             sqlQueryObject.addInsertField("contesto_esterno", "?");
  1029.             sqlQueryObject.addInsertField("base_url", "?");
  1030.             sqlQueryObject.addInsertField("protocollo", "?");
  1031.             sqlQueryObject.addInsertField("ruolo", "?");
  1032.             sqlQueryObject.addInsertField("service_binding", "?");
  1033.             sqlQueryObject.addInsertField("tipo_soggetto", "?");
  1034.             sqlQueryObject.addInsertField("nome_soggetto", "?");
  1035.             String updateQuery = sqlQueryObject.createSQLInsert();
  1036.             updateStmt = con.prepareStatement(updateQuery);
  1037.             int indexP = 1;
  1038.             updateStmt.setString(indexP++, regola.getNome());
  1039.             updateStmt.setInt(indexP++, regola.getPosizione());
  1040.             updateStmt.setString(indexP++, DriverConfigurazioneDBLib.getValue(regola.getStato()));
  1041.             updateStmt.setString(indexP++, regola.getDescrizione());
  1042.             updateStmt.setInt(indexP++, regola.isRegexpr() ? CostantiDB.TRUE : CostantiDB.FALSE);
  1043.             updateStmt.setString(indexP++, regola.getRegola());
  1044.             // 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
  1045.             String s = regola.getContestoEsterno();
  1046.             if("".equals(s)) {
  1047.                 s = CostantiConfigurazione.REGOLA_PROXY_PASS_CONTESTO_VUOTO;
  1048.             }
  1049.             updateStmt.setString(indexP++, s);
  1050.             updateStmt.setString(indexP++, regola.getBaseUrl());
  1051.             updateStmt.setString(indexP++, regola.getProtocollo());
  1052.             updateStmt.setString(indexP++, DriverConfigurazioneDBLib.getValue(regola.getRuolo()));
  1053.             updateStmt.setString(indexP++, DriverConfigurazioneDBLib.getValue(regola.getServiceBinding()));
  1054.             updateStmt.setString(indexP++, regola.getSoggetto()!=null ? regola.getSoggetto().getTipo() : null);
  1055.             updateStmt.setString(indexP++, regola.getSoggetto()!=null ? regola.getSoggetto().getNome() : null);
  1056.             updateStmt.executeUpdate();
  1057.             updateStmt.close();
  1058.             
  1059.         } finally {
  1060.             JDBCUtilities.closeResources(updateStmt);
  1061.         }
  1062.     }
  1063.     
  1064.     public static void CRUDUrlInvocazioneRegola(int type, ConfigurazioneUrlInvocazioneRegola regola, Connection con) throws DriverConfigurazioneException {
  1065.         if (regola == null)
  1066.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDUrlInvocazioneRegola] La regola non può essere NULL");
  1067.         PreparedStatement updateStmt = null;
  1068.         String updateQuery = "";
  1069.         

  1071.         try {
  1072.             
  1073.             if(regola.getNome()==null) {
  1074.                 throw new DriverConfigurazioneException("Nome non fornito");
  1075.             }
  1076.             
  1077.             // Recupero id generic properties
  1078.             long idParent = -1;
  1079.             if(type == CostantiDB.UPDATE || type == CostantiDB.DELETE) {
  1080.                 
  1081.                 String oldNome = regola.getNome();
  1082.                 if(type == CostantiDB.UPDATE && regola.getOldNome()!=null) {
  1083.                     oldNome = regola.getOldNome();
  1084.                 }
  1085.                 
  1086.                 idParent = DBUtils.getUrlInvocazioneRegola(oldNome, con, DriverConfigurazioneDBLib.tipoDB);
  1087.                 if(idParent<=0) {
  1088.                     throw new DriverConfigurazioneException("Regola con nome '"+regola.getNome()+"' non trovata");
  1089.                 }

  1091.                 // delete
  1092.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1093.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_URL_REGOLE);
  1094.                 sqlQueryObject.addWhereCondition("id=?");
  1095.                 updateQuery = sqlQueryObject.createSQLDelete();
  1096.                 updateStmt = con.prepareStatement(updateQuery);
  1097.                 updateStmt.setLong(1, idParent);
  1098.                 updateStmt.executeUpdate();
  1099.                 updateStmt.close();
  1100.             }
  1101.             

  1103.             switch (type) {
  1104.             case CREATE:
  1105.             case UPDATE:
  1106.         
  1107.                 // insert

  1109.                 createUrlInvocazioneRegolaEngine(regola, con);

  1111.                 break;
  1112.             case DELETE:
  1113.                 // non rimuovo in quanto gia fatto sopra.
  1114.                 break;
  1115.             default:
  1116.                 break;
  1117.             }


  1120.         } catch (SQLException se) {
  1121.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPlugin] SQLException [" + se.getMessage() + "].",se);
  1122.         }catch (Exception se) {
  1123.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPlugin] Exception [" + se.getMessage() + "].",se);
  1124.         } finally {
  1125.             JDBCUtilities.closeResources(updateStmt);
  1126.         }

  1128.     }
  1129.     
  1130.     
  1131.     
  1132.     
  1133.     public static long CRUDConfigurazioneGenerale(int type, Configurazione config, Connection con) throws DriverConfigurazioneException {
  1134.         
  1135.         if(config.sizeExtendedInfoList()>0 && 
  1136.                 config.getRoutingTable()==null && 
  1137.                 config.getAccessoRegistro()==null &&
  1138.                 config.getAccessoConfigurazione()==null && 
  1139.                 config.getAccessoDatiAutorizzazione()==null &&
  1140.                 config.getAccessoDatiAutenticazione()==null && 
  1141.                 config.getMultitenant()==null &&
  1142.                 config.getUrlInvocazione()==null &&
  1143.                 config.getValidazioneBuste()==null && 
  1144.                 config.getValidazioneContenutiApplicativi()==null &&
  1145.                 config.getIndirizzoRisposta()==null &&  
  1146.                 config.getAttachments()==null &&
  1147.                 config.getRisposte()==null &&
  1148.                 config.getInoltroBusteNonRiscontrate()==null && 
  1149.                 config.getMessaggiDiagnostici()==null && 
  1150.                 config.getTracciamento()==null &&
  1151.                 config.getTransazioni()==null &&
  1152.                 config.getDump()==null &&       
  1153.                 config.getGestioneErrore()==null && 
  1154.                 config.getIntegrationManager()==null &&
  1155.                 config.getStatoServiziPdd()==null &&
  1156.                 config.getSystemProperties()==null && 
  1157.                 (config.getGenericPropertiesList()==null || config.getGenericPropertiesList().isEmpty()) &&
  1158.                 config.getGestioneCors()==null && 
  1159.                 config.getResponseCaching()==null &&
  1160.                 config.getGestioneCanali()==null &&
  1161.                 config.getRegistroPlugins()==null &&
  1162.                 config.getConfigurazioneHandler()==null) {
  1163.                         
  1164.             // caso speciale extended info
  1165.             ExtendedInfoManager extInfoManager = ExtendedInfoManager.getInstance();
  1166.             IExtendedInfo extInfoConfigurazioneDriver = extInfoManager.newInstanceExtendedInfoConfigurazione();
  1167.             if(extInfoConfigurazioneDriver!=null){
  1168.             
  1169.                 try{
  1170.                     CRUDType crudType = null;
  1171.                     switch (type) {
  1172.                     case CREATE:
  1173.                         crudType = CRUDType.CREATE;
  1174.                         break;
  1175.                     case UPDATE:
  1176.                         crudType = CRUDType.UPDATE;
  1177.                         break;
  1178.                     case DELETE:
  1179.                         crudType = CRUDType.DELETE;
  1180.                         break;
  1181.                     default:
  1182.                         break;
  1183.                     }
  1184.                     
  1185.                     switch (type) {
  1186.                     case CREATE:
  1187.                     case UPDATE:
  1188.                         if(config.sizeExtendedInfoList()>0){
  1189.                             for(int l=0; l<config.sizeExtendedInfoList();l++){
  1190.                                 extInfoConfigurazioneDriver.deleteExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), crudType);
  1191.                                 extInfoConfigurazioneDriver.createExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), crudType);
  1192.                             }
  1193.                         }
  1194.                         break;
  1195.                     case DELETE:
  1196.                         if(config.sizeExtendedInfoList()>0){
  1197.                             for(int l=0; l<config.sizeExtendedInfoList();l++){
  1198.                                 extInfoConfigurazioneDriver.deleteExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), crudType);
  1199.                             }
  1200.                         }
  1201.                         break;
  1202.                     default:
  1203.                         break;
  1204.                     }
  1205.                 }catch (Exception se) {
  1206.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConfigurazioneGenerale-Extended] Exception [" + se.getMessage() + "].",se);
  1207.                 } 
  1208.                 
  1209.             }
  1210.             
  1211.             return -1;
  1212.             
  1213.         }
  1214.         else{
  1215.             
  1216.             return engineCRUDConfigurazioneGenerale(type, config, con);
  1217.             
  1218.         }
  1219.         
  1220.     }

  1222.     @SuppressWarnings("deprecation")
  1223.     private static DumpConfigurazione getDumpConfigurazioneDeprecated(Dump dump) {
  1224.         return dump.getConfigurazione();
  1225.     }
  1226.     
  1227.     private static long engineCRUDConfigurazioneGenerale(int type, Configurazione config, Connection con) throws DriverConfigurazioneException {
  1228.         PreparedStatement updateStmt = null;
  1229.         String updateQuery = "";
  1230.         PreparedStatement selectStmt = null;
  1231.         ResultSet selectRS = null;
  1232.         int n = 0;
  1233.         long idConfigurazione = 0;

  1235.         IndirizzoRisposta indirizzoPerRisposta = config.getIndirizzoRisposta();
  1236.         InoltroBusteNonRiscontrate inoltroBusteNonRiscontrate = config.getInoltroBusteNonRiscontrate();
  1237.         IntegrationManager integrationManager = config.getIntegrationManager();
  1238.         MessaggiDiagnostici messaggiDiagnostici = config.getMessaggiDiagnostici();
  1239.         Risposte risposte = config.getRisposte();
  1240.         ValidazioneBuste validazioneBuste = config.getValidazioneBuste();
  1241.         AccessoRegistro car = config.getAccessoRegistro();
  1242.         AccessoConfigurazione aConfig = config.getAccessoConfigurazione();
  1243.         AccessoDatiAutorizzazione aDatiAuthz = config.getAccessoDatiAutorizzazione();
  1244.         AccessoDatiAutenticazione aDatiAuthn = config.getAccessoDatiAutenticazione();
  1245.         AccessoDatiGestioneToken aDatiGestioneToken = config.getAccessoDatiGestioneToken();
  1246.         AccessoDatiAttributeAuthority aDatiAttributeAuthority = config.getAccessoDatiAttributeAuthority();
  1247.         AccessoDatiKeystore aDatiKeystore = config.getAccessoDatiKeystore();
  1248.         AccessoDatiRichieste aDatiRichieste = config.getAccessoDatiRichieste();
  1249.         Attachments att = config.getAttachments();

  1251.         ConfigurazioneMultitenant multitenant = config.getMultitenant();
  1252.         
  1253.         CorsConfigurazione corsConfigurazione = config.getGestioneCors();
  1254.         String corsStato = null;
  1255.         String corsTipo = null; 
  1256.         String corsAllAllowOrigins = null; 
  1257.         String corsAllAllowMethods = null; 
  1258.         String corsAllAllowHeaders = null; 
  1259.         String corsAllowCredentials = null; 
  1260.         int corsAllowMaxAge = CostantiDB.FALSE;
  1261.         Integer corsAllowMaxAgeSeconds = null;
  1262.         String corsAllowOrigins = null; 
  1263.         String corsAllowHeaders = null; 
  1264.         String corsAllowMethods = null; 
  1265.         String corsAllowExposeHeaders = null; 
  1266.         if(corsConfigurazione!=null) {
  1267.             corsStato = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getStato());
  1268.             corsTipo = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getTipo());
  1269.             corsAllAllowOrigins = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getAccessControlAllAllowOrigins());
  1270.             corsAllAllowMethods = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getAccessControlAllAllowMethods());
  1271.             corsAllAllowHeaders = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getAccessControlAllAllowHeaders());
  1272.             corsAllowCredentials = DriverConfigurazioneDBLib.getValue(corsConfigurazione.getAccessControlAllowCredentials());
  1273.             if(corsConfigurazione.getAccessControlMaxAge()!=null) {
  1274.                 corsAllowMaxAge = CostantiDB.TRUE;
  1275.                 corsAllowMaxAgeSeconds = corsConfigurazione.getAccessControlMaxAge();   
  1276.             }
  1277.             if(corsConfigurazione.getAccessControlAllowOrigins()!=null && corsConfigurazione.getAccessControlAllowOrigins().sizeOriginList()>0) {
  1278.                 StringBuilder bf = new StringBuilder();
  1279.                 for (int i = 0; i < corsConfigurazione.getAccessControlAllowOrigins().sizeOriginList(); i++) {
  1280.                     if(i>0) {
  1281.                         bf.append(",");
  1282.                     }
  1283.                     bf.append(corsConfigurazione.getAccessControlAllowOrigins().getOrigin(i));
  1284.                 }
  1285.                 corsAllowOrigins = bf.toString();
  1286.             }
  1287.             if(corsConfigurazione.getAccessControlAllowHeaders()!=null && corsConfigurazione.getAccessControlAllowHeaders().sizeHeaderList()>0) {
  1288.                 StringBuilder bf = new StringBuilder();
  1289.                 for (int i = 0; i < corsConfigurazione.getAccessControlAllowHeaders().sizeHeaderList(); i++) {
  1290.                     if(i>0) {
  1291.                         bf.append(",");
  1292.                     }
  1293.                     bf.append(corsConfigurazione.getAccessControlAllowHeaders().getHeader(i));
  1294.                 }
  1295.                 corsAllowHeaders = bf.toString();
  1296.             }
  1297.             if(corsConfigurazione.getAccessControlAllowMethods()!=null && corsConfigurazione.getAccessControlAllowMethods().sizeMethodList()>0) {
  1298.                 StringBuilder bf = new StringBuilder();
  1299.                 for (int i = 0; i < corsConfigurazione.getAccessControlAllowMethods().sizeMethodList(); i++) {
  1300.                     if(i>0) {
  1301.                         bf.append(",");
  1302.                     }
  1303.                     bf.append(corsConfigurazione.getAccessControlAllowMethods().getMethod(i));
  1304.                 }
  1305.                 corsAllowMethods = bf.toString();
  1306.             }
  1307.             if(corsConfigurazione.getAccessControlExposeHeaders()!=null && corsConfigurazione.getAccessControlExposeHeaders().sizeHeaderList()>0) {
  1308.                 StringBuilder bf = new StringBuilder();
  1309.                 for (int i = 0; i < corsConfigurazione.getAccessControlExposeHeaders().sizeHeaderList(); i++) {
  1310.                     if(i>0) {
  1311.                         bf.append(",");
  1312.                     }
  1313.                     bf.append(corsConfigurazione.getAccessControlExposeHeaders().getHeader(i));
  1314.                 }
  1315.                 corsAllowExposeHeaders = bf.toString();
  1316.             }
  1317.         }
  1318.         
  1319.         ResponseCachingConfigurazioneGenerale responseCachingConfigurazione = config.getResponseCaching();
  1320.         
  1321.         String responseCacheStato = null;
  1322.         Integer responseCacheSeconds = null;
  1323.         Long responseCacheMaxMsgSize = null;
  1324.         String responseCacheHashUrl = null;
  1325.         String responseCacheHashQuery = null;
  1326.         String responseCacheHashQueryList = null;
  1327.         String responseCacheHashHeaders = null;
  1328.         String responseCacheHashHeadersList = null;
  1329.         String responseCacheHashPayload = null;
  1330.         boolean responseCacheNoCache = true;
  1331.         boolean responseCacheMaxAge = true;
  1332.         boolean responseCacheNoStore = true;
  1333.         List<ResponseCachingConfigurazioneRegola> responseCacheRegole = null;
  1334.         if(responseCachingConfigurazione!=null && responseCachingConfigurazione.getConfigurazione()!=null) {
  1335.             responseCacheStato = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazione.getConfigurazione().getStato());
  1336.             responseCacheSeconds = responseCachingConfigurazione.getConfigurazione().getCacheTimeoutSeconds();
  1337.             responseCacheMaxMsgSize = responseCachingConfigurazione.getConfigurazione().getMaxMessageSize();
  1338.             if(responseCachingConfigurazione.getConfigurazione().getControl()!=null) {
  1339.                 responseCacheNoCache = responseCachingConfigurazione.getConfigurazione().getControl().getNoCache();
  1340.                 responseCacheMaxAge = responseCachingConfigurazione.getConfigurazione().getControl().getMaxAge();
  1341.                 responseCacheNoStore = responseCachingConfigurazione.getConfigurazione().getControl().getNoStore();
  1342.             }
  1343.             if(responseCachingConfigurazione.getConfigurazione().getHashGenerator()!=null) {
  1344.                 responseCacheHashUrl = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazione.getConfigurazione().getHashGenerator().getRequestUri());
  1345.                 
  1346.                 responseCacheHashQuery = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazione.getConfigurazione().getHashGenerator().getQueryParameters());
  1347.                 if(StatoFunzionalitaCacheDigestQueryParameter.SELEZIONE_PUNTUALE.equals(responseCachingConfigurazione.getConfigurazione().getHashGenerator().getQueryParameters()) &&
  1348.                     (responseCachingConfigurazione.getConfigurazione().getHashGenerator().getQueryParameterList()!=null && responseCachingConfigurazione.getConfigurazione().getHashGenerator().sizeQueryParameterList()>0) 
  1349.                     ){
  1350.                     StringBuilder bf = new StringBuilder();
  1351.                     for (int i = 0; i < responseCachingConfigurazione.getConfigurazione().getHashGenerator().sizeQueryParameterList(); i++) {
  1352.                         if(i>0) {
  1353.                             bf.append(",");
  1354.                         }
  1355.                         bf.append(responseCachingConfigurazione.getConfigurazione().getHashGenerator().getQueryParameter(i));
  1356.                     }
  1357.                     responseCacheHashQueryList = bf.toString();
  1358.                 }
  1359.                 
  1360.                 responseCacheHashHeaders = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazione.getConfigurazione().getHashGenerator().getHeaders());
  1361.                 if(StatoFunzionalita.ABILITATO.equals(responseCachingConfigurazione.getConfigurazione().getHashGenerator().getHeaders()) &&
  1362.                     (responseCachingConfigurazione.getConfigurazione().getHashGenerator().getHeaderList()!=null && responseCachingConfigurazione.getConfigurazione().getHashGenerator().sizeHeaderList()>0) 
  1363.                     ){
  1364.                     StringBuilder bf = new StringBuilder();
  1365.                     for (int i = 0; i < responseCachingConfigurazione.getConfigurazione().getHashGenerator().sizeHeaderList(); i++) {
  1366.                         if(i>0) {
  1367.                             bf.append(",");
  1368.                         }
  1369.                         bf.append(responseCachingConfigurazione.getConfigurazione().getHashGenerator().getHeader(i));
  1370.                     }
  1371.                     responseCacheHashHeadersList = bf.toString();
  1372.                 }
  1373.                 
  1374.                 responseCacheHashPayload = DriverConfigurazioneDBLib.getValue(responseCachingConfigurazione.getConfigurazione().getHashGenerator().getPayload());
  1375.             }
  1376.             responseCacheRegole = responseCachingConfigurazione.getConfigurazione().getRegolaList();
  1377.         }
  1378.         
  1379.         Cache responseCachingCache = null;
  1380.         String responseCachingDimensioneCache = null;
  1381.         String responseCachingAlgoritmoCache = null;
  1382.         String responseCachingIdleCache = null;
  1383.         String responseCachingLifeCache = null;
  1384.         String responseCachingStatoCache = null;
  1385.         if(responseCachingConfigurazione !=null){
  1386.             responseCachingCache = responseCachingConfigurazione.getCache();

  1388.         }
  1389.         responseCachingStatoCache = (responseCachingCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1390.         if (responseCachingStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1391.             responseCachingDimensioneCache = responseCachingCache.getDimensione();
  1392.             responseCachingAlgoritmoCache = DriverConfigurazioneDBLib.getValue(responseCachingCache.getAlgoritmo());
  1393.             responseCachingIdleCache = responseCachingCache.getItemIdleTime();
  1394.             responseCachingLifeCache = responseCachingCache.getItemLifeSecond();
  1395.         }
  1396.         
  1397.         
  1398.         Cache consegnaCache = null;
  1399.         String consegnaDimensioneCache = null;
  1400.         String consegnaAlgoritmoCache = null;
  1401.         String consegnaIdleCache = null;
  1402.         String consegnaLifeCache = null;
  1403.         String consegnaStatoCache = null;
  1404.         if(config.getAccessoDatiConsegnaApplicativi() !=null){
  1405.             consegnaCache = config.getAccessoDatiConsegnaApplicativi().getCache();

  1407.         }
  1408.         consegnaStatoCache = (consegnaCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1409.         if (consegnaStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1410.             consegnaDimensioneCache = consegnaCache.getDimensione();
  1411.             consegnaAlgoritmoCache = DriverConfigurazioneDBLib.getValue(consegnaCache.getAlgoritmo());
  1412.             consegnaIdleCache = consegnaCache.getItemIdleTime();
  1413.             consegnaLifeCache = consegnaCache.getItemLifeSecond();
  1414.         }
  1415.         
  1416.         String utilizzoIndTelematico = null;
  1417.         if(indirizzoPerRisposta!=null){
  1418.             utilizzoIndTelematico = DriverConfigurazioneDBLib.getValue(indirizzoPerRisposta.getUtilizzo());
  1419.         }
  1420.         String cadenzaInoltro = null;
  1421.         if(inoltroBusteNonRiscontrate!=null){
  1422.             cadenzaInoltro = inoltroBusteNonRiscontrate.getCadenza();
  1423.         }
  1424.         String autenticazione = null;
  1425.         if(integrationManager!=null){
  1426.             autenticazione = integrationManager.getAutenticazione();
  1427.         }
  1428.         String msgDiagSeverita = null;
  1429.         String msgDiagSeveritaLog4j = null;
  1430.         if(messaggiDiagnostici!=null){
  1431.             msgDiagSeverita = DriverConfigurazioneDBLib.getValue(messaggiDiagnostici.getSeverita());
  1432.             msgDiagSeveritaLog4j = DriverConfigurazioneDBLib.getValue(messaggiDiagnostici.getSeveritaLog4j());
  1433.         }
  1434.         String valControllo = null;
  1435.         String valStato = null;
  1436.         String valManifest = null;
  1437.         String valProfiloCollaborazione = null;
  1438.         if(validazioneBuste!=null){
  1439.             valControllo = DriverConfigurazioneDBLib.getValue(validazioneBuste.getControllo());
  1440.             valStato = DriverConfigurazioneDBLib.getValue(validazioneBuste.getStato());
  1441.             valManifest = DriverConfigurazioneDBLib.getValue(validazioneBuste.getManifestAttachments());
  1442.             valProfiloCollaborazione = DriverConfigurazioneDBLib.getValue(validazioneBuste.getProfiloCollaborazione());
  1443.         }

  1445.         String gestioneManifest = null;
  1446.         if(att!=null){
  1447.             gestioneManifest = DriverConfigurazioneDBLib.getValue(att.getGestioneManifest());
  1448.         }

  1450.         Cache registroCache = null;
  1451.         String registroDimensioneCache = null;
  1452.         String registroAlgoritmoCache = null;
  1453.         String registroIdleCache = null;
  1454.         String registroLifeCache = null;
  1455.         String registroStatoCache = null;
  1456.         if(car !=null){
  1457.             registroCache = car.getCache();

  1459.         }
  1460.         registroStatoCache = (registroCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1461.         if (registroStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1462.             registroDimensioneCache = registroCache.getDimensione();
  1463.             registroAlgoritmoCache = DriverConfigurazioneDBLib.getValue(registroCache.getAlgoritmo());
  1464.             registroIdleCache = registroCache.getItemIdleTime();
  1465.             registroLifeCache = registroCache.getItemLifeSecond();
  1466.         }
  1467.         
  1468.         Cache configCache = null;
  1469.         String configDimensioneCache = null;
  1470.         String configAlgoritmoCache = null;
  1471.         String configIdleCache = null;
  1472.         String configLifeCache = null;
  1473.         String configStatoCache = null;
  1474.         if(aConfig !=null){
  1475.             configCache = aConfig.getCache();

  1477.         }
  1478.         configStatoCache = (configCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1479.         if (configStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1480.             configDimensioneCache = configCache.getDimensione();
  1481.             configAlgoritmoCache = DriverConfigurazioneDBLib.getValue(configCache.getAlgoritmo());
  1482.             configIdleCache = configCache.getItemIdleTime();
  1483.             configLifeCache = configCache.getItemLifeSecond();
  1484.         }
  1485.         
  1486.         Cache authzCache = null;
  1487.         String authzDimensioneCache = null;
  1488.         String authzAlgoritmoCache = null;
  1489.         String authzIdleCache = null;
  1490.         String authzLifeCache = null;
  1491.         String authzStatoCache = null;
  1492.         if(aDatiAuthz !=null){
  1493.             authzCache = aDatiAuthz.getCache();

  1495.         }
  1496.         authzStatoCache = (authzCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1497.         if (authzStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1498.             authzDimensioneCache = authzCache.getDimensione();
  1499.             authzAlgoritmoCache = DriverConfigurazioneDBLib.getValue(authzCache.getAlgoritmo());
  1500.             authzIdleCache = authzCache.getItemIdleTime();
  1501.             authzLifeCache = authzCache.getItemLifeSecond();
  1502.         }
  1503.         
  1504.         Cache authnCache = null;
  1505.         String authnDimensioneCache = null;
  1506.         String authnAlgoritmoCache = null;
  1507.         String authnIdleCache = null;
  1508.         String authnLifeCache = null;
  1509.         String authnStatoCache = null;
  1510.         if(aDatiAuthn !=null){
  1511.             authnCache = aDatiAuthn.getCache();

  1513.         }
  1514.         authnStatoCache = (authnCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1515.         if (authnStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1516.             authnDimensioneCache = authnCache.getDimensione();
  1517.             authnAlgoritmoCache = DriverConfigurazioneDBLib.getValue(authnCache.getAlgoritmo());
  1518.             authnIdleCache = authnCache.getItemIdleTime();
  1519.             authnLifeCache = authnCache.getItemLifeSecond();
  1520.         }
  1521.         
  1522.         Cache tokenCache = null;
  1523.         String tokenDimensioneCache = null;
  1524.         String tokenAlgoritmoCache = null;
  1525.         String tokenIdleCache = null;
  1526.         String tokenLifeCache = null;
  1527.         String tokenStatoCache = null;
  1528.         if(aDatiGestioneToken !=null){
  1529.             tokenCache = aDatiGestioneToken.getCache();
  1530.         }
  1531.         tokenStatoCache = (tokenCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1532.         if (tokenStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1533.             tokenDimensioneCache = tokenCache.getDimensione();
  1534.             tokenAlgoritmoCache = DriverConfigurazioneDBLib.getValue(tokenCache.getAlgoritmo());
  1535.             tokenIdleCache = tokenCache.getItemIdleTime();
  1536.             tokenLifeCache = tokenCache.getItemLifeSecond();
  1537.         }
  1538.         
  1539.         Cache aaCache = null;
  1540.         String aaDimensioneCache = null;
  1541.         String aaAlgoritmoCache = null;
  1542.         String aaIdleCache = null;
  1543.         String aaLifeCache = null;
  1544.         String aaStatoCache = null;
  1545.         if(aDatiAttributeAuthority !=null){
  1546.             aaCache = aDatiAttributeAuthority.getCache();
  1547.         }
  1548.         aaStatoCache = (aaCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1549.         if (aaStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1550.             aaDimensioneCache = aaCache.getDimensione();
  1551.             aaAlgoritmoCache = DriverConfigurazioneDBLib.getValue(aaCache.getAlgoritmo());
  1552.             aaIdleCache = aaCache.getItemIdleTime();
  1553.             aaLifeCache = aaCache.getItemLifeSecond();
  1554.         }
  1555.         
  1556.         Cache keystoreCache = null;
  1557.         String keystoreDimensioneCache = null;
  1558.         String keystoreAlgoritmoCache = null;
  1559.         String keystoreIdleCache = null;
  1560.         String keystoreLifeCache = null;
  1561.         String keystoreStatoCache = null;
  1562.         String keystoreCrlLifeCache = null;
  1563.         if(aDatiKeystore !=null){
  1564.             keystoreCache = aDatiKeystore.getCache();
  1565.             keystoreCrlLifeCache = aDatiKeystore.getCrlItemLifeSecond();

  1567.         }
  1568.         keystoreStatoCache = (keystoreCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1569.         if (keystoreStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1570.             keystoreDimensioneCache = keystoreCache.getDimensione();
  1571.             keystoreAlgoritmoCache = DriverConfigurazioneDBLib.getValue(keystoreCache.getAlgoritmo());
  1572.             keystoreIdleCache = keystoreCache.getItemIdleTime();
  1573.             keystoreLifeCache = keystoreCache.getItemLifeSecond();
  1574.         }
  1575.         
  1576.         Cache datiRichiesteCache = null;
  1577.         String datiRichiesteDimensioneCache = null;
  1578.         String datiRichiesteAlgoritmoCache = null;
  1579.         String datiRichiesteIdleCache = null;
  1580.         String datiRichiesteLifeCache = null;
  1581.         String datiRichiesteStatoCache = null;
  1582.         if(aDatiRichieste !=null){
  1583.             datiRichiesteCache = aDatiRichieste.getCache();
  1584.         }
  1585.         datiRichiesteStatoCache = (datiRichiesteCache != null ? CostantiConfigurazione.ABILITATO.toString() : CostantiConfigurazione.DISABILITATO.toString());
  1586.         if (datiRichiesteStatoCache.equals(CostantiConfigurazione.ABILITATO.toString())) {
  1587.             datiRichiesteDimensioneCache = datiRichiesteCache.getDimensione();
  1588.             datiRichiesteAlgoritmoCache = DriverConfigurazioneDBLib.getValue(datiRichiesteCache.getAlgoritmo());
  1589.             datiRichiesteIdleCache = datiRichiesteCache.getItemIdleTime();
  1590.             datiRichiesteLifeCache = datiRichiesteCache.getItemLifeSecond();
  1591.         }

  1593.         Tracciamento t = config.getTracciamento();
  1594.         String tracciamentoBuste = null;
  1595.         if (t != null) {
  1596.             tracciamentoBuste = DriverConfigurazioneDBLib.getValue(t.getStato());           
  1597.         }
  1598.         
  1599.         String tracciamentoEsitiPD = null;
  1600.         String transazioniTempiElaborazionePD = null;
  1601.         String transazioniTokenPD = null;
  1602.         ConfigurazioneTracciamentoPorta tracciamentoPD = null;
  1603.         if (t != null) {
  1604.             tracciamentoPD =t.getPortaDelegata();
  1605.         }
  1606.         TracciamentoConfigurazione tracciamentoConfigurazioneDatabasePD = null;
  1607.         TracciamentoConfigurazione tracciamentoConfigurazioneFiletracePD = null;
  1608.         TracciamentoConfigurazioneFiletrace tracciamentoConfigurazioneFiletraceDetailsPD = null;
  1609.         if(tracciamentoPD!=null) {
  1610.             tracciamentoEsitiPD = tracciamentoPD.getEsiti();
  1611.             if(tracciamentoPD.getTransazioni()!=null) {
  1612.                 transazioniTempiElaborazionePD = DriverConfigurazioneDBLib.getValue(tracciamentoPD.getTransazioni().getTempiElaborazione());
  1613.                 transazioniTokenPD = DriverConfigurazioneDBLib.getValue(tracciamentoPD.getTransazioni().getToken());
  1614.             }
  1615.             tracciamentoConfigurazioneDatabasePD = tracciamentoPD.getDatabase();
  1616.             tracciamentoConfigurazioneFiletracePD = tracciamentoPD.getFiletrace();
  1617.             tracciamentoConfigurazioneFiletraceDetailsPD = tracciamentoPD.getFiletraceConfig();
  1618.         }
  1619.         else {
  1620.             // backward compatibility, lo uso sia per erogazione che per fruizione (per import package)
  1621.             
  1622.             if (t != null) {
  1623.                 tracciamentoEsitiPD = t.getEsiti();
  1624.             }
  1625.             
  1626.             Transazioni transazioni = config.getTransazioni();
  1627.             if(transazioni!=null) {
  1628.                 transazioniTempiElaborazionePD = DriverConfigurazioneDBLib.getValue(transazioni.getTempiElaborazione());
  1629.                 transazioniTokenPD = DriverConfigurazioneDBLib.getValue(transazioni.getToken());
  1630.             }
  1631.         }
  1632.         
  1633.         String tracciamentoEsitiPA = null;
  1634.         String transazioniTempiElaborazionePA = null;
  1635.         String transazioniTokenPA = null;
  1636.         ConfigurazioneTracciamentoPorta tracciamentoPA = null;
  1637.         if (t != null) {
  1638.             tracciamentoPA = t.getPortaApplicativa();
  1639.         }
  1640.         TracciamentoConfigurazione tracciamentoConfigurazioneDatabasePA = null;
  1641.         TracciamentoConfigurazione tracciamentoConfigurazioneFiletracePA = null;
  1642.         TracciamentoConfigurazioneFiletrace tracciamentoConfigurazioneFiletraceDetailsPA = null;
  1643.         if(tracciamentoPA!=null) {
  1644.             tracciamentoEsitiPA = tracciamentoPA.getEsiti();
  1645.             if(tracciamentoPA.getTransazioni()!=null) {
  1646.                 transazioniTempiElaborazionePA = DriverConfigurazioneDBLib.getValue(tracciamentoPA.getTransazioni().getTempiElaborazione());
  1647.                 transazioniTokenPA = DriverConfigurazioneDBLib.getValue(tracciamentoPA.getTransazioni().getToken());
  1648.             }
  1649.             tracciamentoConfigurazioneDatabasePA = tracciamentoPA.getDatabase();
  1650.             tracciamentoConfigurazioneFiletracePA = tracciamentoPA.getFiletrace();
  1651.             tracciamentoConfigurazioneFiletraceDetailsPA = tracciamentoPA.getFiletraceConfig();
  1652.         }
  1653.         else {
  1654.             // backward compatibility, lo uso sia per erogazione che per fruizione (per import package)
  1655.             
  1656.             if (t != null) {
  1657.                 tracciamentoEsitiPA = t.getEsiti();
  1658.             }
  1659.             
  1660.             Transazioni transazioni = config.getTransazioni();
  1661.             if(transazioni!=null) {
  1662.                 transazioniTempiElaborazionePA = DriverConfigurazioneDBLib.getValue(transazioni.getTempiElaborazione());
  1663.                 transazioniTokenPA = DriverConfigurazioneDBLib.getValue(transazioni.getToken());
  1664.             }
  1665.         }
  1666.         

  1668.         
  1669.         Dump d = config.getDump();
  1670.         String dumpApplicativo = null;
  1671.         String dumpPD = null;
  1672.         String dumpPA = null;
  1673.         DumpConfigurazione dumpConfigPA = null;
  1674.         DumpConfigurazione dumpConfigPD = null;
  1675.         if (d != null) {
  1676.             dumpApplicativo = DriverConfigurazioneDBLib.getValue(d.getStato());
  1677.             dumpPD = DriverConfigurazioneDBLib.getValue(d.getDumpBinarioPortaDelegata());
  1678.             dumpPA = DriverConfigurazioneDBLib.getValue(d.getDumpBinarioPortaApplicativa());
  1679.             
  1680.             DumpConfigurazione dumpConfig = getDumpConfigurazioneDeprecated(d); 
  1681.             if(dumpConfig!=null) {
  1682.                 // backward compatibility, lo uso sia per erogazione che per fruizione (per import package)
  1683.                 dumpConfigPA = dumpConfig;
  1684.                 dumpConfigPD = dumpConfig;
  1685.             }
  1686.             else {
  1687.                 dumpConfigPA = d.getConfigurazionePortaApplicativa();
  1688.                 dumpConfigPD = d.getConfigurazionePortaDelegata();
  1689.             }
  1690.         }
  1691.         
  1692.         String modRisposta = CostantiConfigurazione.CONNECTION_REPLY.toString();
  1693.         if(risposte!=null){
  1694.             modRisposta = (risposte.getConnessione().equals(CostantiConfigurazione.CONNECTION_REPLY) ? 
  1695.                     CostantiConfigurazione.CONNECTION_REPLY.toString() : CostantiConfigurazione.NEW_CONNECTION.toString());
  1696.         }
  1697.         String routingEnabled =  CostantiConfigurazione.DISABILITATO.toString();
  1698.         if(config.getRoutingTable()!=null &&
  1699.             (config.getRoutingTable().getAbilitata()!=null && config.getRoutingTable().getAbilitata())
  1700.             ){
  1701.             routingEnabled =  CostantiConfigurazione.ABILITATO.toString();
  1702.         }
  1703.         
  1704.         String validazioneContenutiStato = null;
  1705.         String validazioneContenutiTipo = null;
  1706.         String validazioneContenutiAcceptMtomMessage = null;
  1707.         if(config.getValidazioneContenutiApplicativi()!=null){
  1708.             validazioneContenutiStato = DriverConfigurazioneDBLib.getValue(config.getValidazioneContenutiApplicativi().getStato());
  1709.             validazioneContenutiTipo = DriverConfigurazioneDBLib.getValue(config.getValidazioneContenutiApplicativi().getTipo());
  1710.             validazioneContenutiAcceptMtomMessage = DriverConfigurazioneDBLib.getValue(config.getValidazioneContenutiApplicativi().getAcceptMtomMessage());
  1711.         }

  1713.         CanaliConfigurazione configurazioneCanali = config.getGestioneCanali();
  1714.         String configurazioneCanaliStato = null;
  1715.         if(configurazioneCanali!=null) {
  1716.             configurazioneCanaliStato = DriverConfigurazioneDBLib.getValue(configurazioneCanali.getStato());
  1717.         }
  1718.         
  1719.         ConfigurazioneGeneraleHandler configHandlers = config.getConfigurazioneHandler();
  1720.         
  1721.         ExtendedInfoManager extInfoManager = ExtendedInfoManager.getInstance();
  1722.         IExtendedInfo extInfoConfigurazioneDriver = extInfoManager.newInstanceExtendedInfoConfigurazione();
  1723.                                     
  1724.         try {
  1725.             switch (type) {
  1726.             case CREATE:
  1727.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1728.                 sqlQueryObject.addInsertTable(CostantiDB.CONFIGURAZIONE);
  1729.                 sqlQueryObject.addInsertField("cadenza_inoltro", "?");
  1730.                 
  1731.                 sqlQueryObject.addInsertField("validazione_stato", "?");
  1732.                 sqlQueryObject.addInsertField("validazione_controllo", "?");
  1733.                 
  1734.                 sqlQueryObject.addInsertField("msg_diag_severita", "?");
  1735.                 sqlQueryObject.addInsertField("msg_diag_severita_log4j", "?");
  1736.                 sqlQueryObject.addInsertField("auth_integration_manager", "?");
  1737.                 sqlQueryObject.addInsertField("validazione_profilo", "?");
  1738.                 sqlQueryObject.addInsertField("mod_risposta", "?");
  1739.                 sqlQueryObject.addInsertField("indirizzo_telematico", "?");
  1740.                 sqlQueryObject.addInsertField("routing_enabled", "?");
  1741.                 sqlQueryObject.addInsertField("gestione_manifest", "?");
  1742.                 sqlQueryObject.addInsertField("validazione_manifest", "?");
  1743.                 sqlQueryObject.addInsertField("tracciamento_buste", "?");
  1744.                 // tracciamento
  1745.                 sqlQueryObject.addInsertField("tracciamento_esiti", "?");
  1746.                 sqlQueryObject.addInsertField("tracciamento_esiti_pd", "?");
  1747.                 sqlQueryObject.addInsertField("transazioni_tempi", "?");
  1748.                 sqlQueryObject.addInsertField("transazioni_tempi_pd", "?");
  1749.                 sqlQueryObject.addInsertField("transazioni_token", "?");
  1750.                 sqlQueryObject.addInsertField("transazioni_token_pd", "?");
  1751.                 // dump
  1752.                 sqlQueryObject.addInsertField("dump", "?");
  1753.                 sqlQueryObject.addInsertField("dump_bin_pd", "?");
  1754.                 sqlQueryObject.addInsertField("dump_bin_pa", "?");
  1755.                 // validazione
  1756.                 sqlQueryObject.addInsertField("validazione_contenuti_stato", "?");
  1757.                 sqlQueryObject.addInsertField("validazione_contenuti_tipo", "?");
  1758.                 sqlQueryObject.addInsertField("validazione_contenuti_mtom", "?");
  1759.                 // registro cache
  1760.                 sqlQueryObject.addInsertField("statocache", "?");
  1761.                 sqlQueryObject.addInsertField("dimensionecache", "?");
  1762.                 sqlQueryObject.addInsertField("algoritmocache", "?");
  1763.                 sqlQueryObject.addInsertField("idlecache", "?");
  1764.                 sqlQueryObject.addInsertField("lifecache", "?");
  1765.                 // config cache
  1766.                 sqlQueryObject.addInsertField("config_statocache", "?");
  1767.                 sqlQueryObject.addInsertField("config_dimensionecache", "?");
  1768.                 sqlQueryObject.addInsertField("config_algoritmocache", "?");
  1769.                 sqlQueryObject.addInsertField("config_idlecache", "?");
  1770.                 sqlQueryObject.addInsertField("config_lifecache", "?");
  1771.                 // authz cache
  1772.                 sqlQueryObject.addInsertField("auth_statocache", "?");
  1773.                 sqlQueryObject.addInsertField("auth_dimensionecache", "?");
  1774.                 sqlQueryObject.addInsertField("auth_algoritmocache", "?");
  1775.                 sqlQueryObject.addInsertField("auth_idlecache", "?");
  1776.                 sqlQueryObject.addInsertField("auth_lifecache", "?");
  1777.                 // authn cache
  1778.                 sqlQueryObject.addInsertField("authn_statocache", "?");
  1779.                 sqlQueryObject.addInsertField("authn_dimensionecache", "?");
  1780.                 sqlQueryObject.addInsertField("authn_algoritmocache", "?");
  1781.                 sqlQueryObject.addInsertField("authn_idlecache", "?");
  1782.                 sqlQueryObject.addInsertField("authn_lifecache", "?");
  1783.                 // gestione token cache
  1784.                 sqlQueryObject.addInsertField("token_statocache", "?");
  1785.                 sqlQueryObject.addInsertField("token_dimensionecache", "?");
  1786.                 sqlQueryObject.addInsertField("token_algoritmocache", "?");
  1787.                 sqlQueryObject.addInsertField("token_idlecache", "?");
  1788.                 sqlQueryObject.addInsertField("token_lifecache", "?");
  1789.                 // gestione aa cache
  1790.                 sqlQueryObject.addInsertField("aa_statocache", "?");
  1791.                 sqlQueryObject.addInsertField("aa_dimensionecache", "?");
  1792.                 sqlQueryObject.addInsertField("aa_algoritmocache", "?");
  1793.                 sqlQueryObject.addInsertField("aa_idlecache", "?");
  1794.                 sqlQueryObject.addInsertField("aa_lifecache", "?");
  1795.                 // keystore cache
  1796.                 sqlQueryObject.addInsertField("keystore_statocache", "?");
  1797.                 sqlQueryObject.addInsertField("keystore_dimensionecache", "?");
  1798.                 sqlQueryObject.addInsertField("keystore_algoritmocache", "?");
  1799.                 sqlQueryObject.addInsertField("keystore_idlecache", "?");
  1800.                 sqlQueryObject.addInsertField("keystore_lifecache", "?");
  1801.                 sqlQueryObject.addInsertField("keystore_crl_lifecache", "?");
  1802.                 // multitenant
  1803.                 sqlQueryObject.addInsertField("multitenant_stato", "?");
  1804.                 sqlQueryObject.addInsertField("multitenant_fruizioni", "?");
  1805.                 sqlQueryObject.addInsertField("multitenant_erogazioni", "?");
  1806.                 // cors
  1807.                 sqlQueryObject.addInsertField("cors_stato", "?");
  1808.                 sqlQueryObject.addInsertField("cors_tipo", "?");
  1809.                 sqlQueryObject.addInsertField("cors_all_allow_origins", "?");
  1810.                 sqlQueryObject.addInsertField("cors_all_allow_methods", "?");
  1811.                 sqlQueryObject.addInsertField("cors_all_allow_headers", "?");
  1812.                 sqlQueryObject.addInsertField("cors_allow_credentials", "?");
  1813.                 sqlQueryObject.addInsertField("cors_allow_max_age", "?");
  1814.                 sqlQueryObject.addInsertField("cors_allow_max_age_seconds", "?");
  1815.                 sqlQueryObject.addInsertField("cors_allow_origins", "?");
  1816.                 sqlQueryObject.addInsertField("cors_allow_headers", "?");
  1817.                 sqlQueryObject.addInsertField("cors_allow_methods", "?");
  1818.                 sqlQueryObject.addInsertField("cors_allow_expose_headers", "?");
  1819.                 // responseCaching
  1820.                 sqlQueryObject.addInsertField("response_cache_stato", "?");
  1821.                 sqlQueryObject.addInsertField("response_cache_seconds", "?");
  1822.                 sqlQueryObject.addInsertField("response_cache_max_msg_size", "?");
  1823.                 sqlQueryObject.addInsertField("response_cache_control_nocache", "?");
  1824.                 sqlQueryObject.addInsertField("response_cache_control_maxage", "?");
  1825.                 sqlQueryObject.addInsertField("response_cache_control_nostore", "?");
  1826.                 sqlQueryObject.addInsertField("response_cache_hash_url", "?");
  1827.                 sqlQueryObject.addInsertField("response_cache_hash_query", "?");
  1828.                 sqlQueryObject.addInsertField("response_cache_hash_query_list", "?");
  1829.                 sqlQueryObject.addInsertField("response_cache_hash_headers", "?");
  1830.                 sqlQueryObject.addInsertField("response_cache_hash_hdr_list", "?");
  1831.                 sqlQueryObject.addInsertField("response_cache_hash_payload", "?");
  1832.                 // responseCaching cache
  1833.                 sqlQueryObject.addInsertField("response_cache_statocache", "?");
  1834.                 sqlQueryObject.addInsertField("response_cache_dimensionecache", "?");
  1835.                 sqlQueryObject.addInsertField("response_cache_algoritmocache", "?");
  1836.                 sqlQueryObject.addInsertField("response_cache_idlecache", "?");
  1837.                 sqlQueryObject.addInsertField("response_cache_lifecache", "?");
  1838.                 // consegna applicativi cache
  1839.                 sqlQueryObject.addInsertField("consegna_statocache", "?");
  1840.                 sqlQueryObject.addInsertField("consegna_dimensionecache", "?");
  1841.                 sqlQueryObject.addInsertField("consegna_algoritmocache", "?");
  1842.                 sqlQueryObject.addInsertField("consegna_idlecache", "?");
  1843.                 sqlQueryObject.addInsertField("consegna_lifecache", "?");
  1844.                 // canali
  1845.                 sqlQueryObject.addInsertField("canali_stato", "?");
  1846.                 // dati richieste cache
  1847.                 sqlQueryObject.addInsertField("dati_richieste_statocache", "?");
  1848.                 sqlQueryObject.addInsertField("dati_richieste_dimensionecache", "?");
  1849.                 sqlQueryObject.addInsertField("dati_richieste_algoritmocache", "?");
  1850.                 sqlQueryObject.addInsertField("dati_richieste_idlecache", "?");
  1851.                 sqlQueryObject.addInsertField("dati_richieste_lifecache", "?");

  1853.                 updateQuery = sqlQueryObject.createSQLInsert();
  1854.                 updateStmt = con.prepareStatement(updateQuery);

  1856.                 int index = 1;
  1857.                 
  1858.                 updateStmt.setString(index++, cadenzaInoltro);
  1859.                 updateStmt.setString(index++, valStato);
  1860.                 updateStmt.setString(index++, valControllo);
  1861.                 updateStmt.setString(index++, msgDiagSeverita);
  1862.                 updateStmt.setString(index++, msgDiagSeveritaLog4j);
  1863.                 updateStmt.setString(index++, autenticazione);
  1864.                 updateStmt.setString(index++, valProfiloCollaborazione);
  1865.                 updateStmt.setString(index++, modRisposta);
  1866.                 updateStmt.setString(index++, utilizzoIndTelematico);
  1867.                 updateStmt.setString(index++, routingEnabled);
  1868.                 updateStmt.setString(index++, gestioneManifest);
  1869.                 updateStmt.setString(index++, valManifest);
  1870.                 updateStmt.setString(index++, tracciamentoBuste);
  1871.                 // tracciamento
  1872.                 updateStmt.setString(index++, tracciamentoEsitiPA);
  1873.                 updateStmt.setString(index++, tracciamentoEsitiPD);
  1874.                 updateStmt.setString(index++, transazioniTempiElaborazionePA);
  1875.                 updateStmt.setString(index++, transazioniTempiElaborazionePD);
  1876.                 updateStmt.setString(index++, transazioniTokenPA);
  1877.                 updateStmt.setString(index++, transazioniTokenPD);
  1878.                 // dump
  1879.                 updateStmt.setString(index++, dumpApplicativo);
  1880.                 updateStmt.setString(index++, dumpPD);
  1881.                 updateStmt.setString(index++, dumpPA);
  1882.                 // validazione
  1883.                 updateStmt.setString(index++, validazioneContenutiStato);
  1884.                 updateStmt.setString(index++, validazioneContenutiTipo);
  1885.                 updateStmt.setString(index++, validazioneContenutiAcceptMtomMessage);
  1886.                 // registro cache
  1887.                 updateStmt.setString(index++, registroStatoCache);
  1888.                 updateStmt.setString(index++, registroDimensioneCache);
  1889.                 updateStmt.setString(index++, registroAlgoritmoCache);
  1890.                 updateStmt.setString(index++, registroIdleCache);
  1891.                 updateStmt.setString(index++, registroLifeCache);
  1892.                 // config cache
  1893.                 updateStmt.setString(index++, configStatoCache);
  1894.                 updateStmt.setString(index++, configDimensioneCache);
  1895.                 updateStmt.setString(index++, configAlgoritmoCache);
  1896.                 updateStmt.setString(index++, configIdleCache);
  1897.                 updateStmt.setString(index++, configLifeCache);
  1898.                 // authz cache
  1899.                 updateStmt.setString(index++, authzStatoCache);
  1900.                 updateStmt.setString(index++, authzDimensioneCache);
  1901.                 updateStmt.setString(index++, authzAlgoritmoCache);
  1902.                 updateStmt.setString(index++, authzIdleCache);
  1903.                 updateStmt.setString(index++, authzLifeCache);
  1904.                 // authn cache
  1905.                 updateStmt.setString(index++, authnStatoCache);
  1906.                 updateStmt.setString(index++, authnDimensioneCache);
  1907.                 updateStmt.setString(index++, authnAlgoritmoCache);
  1908.                 updateStmt.setString(index++, authnIdleCache);
  1909.                 updateStmt.setString(index++, authnLifeCache);
  1910.                 // token cache
  1911.                 updateStmt.setString(index++, tokenStatoCache);
  1912.                 updateStmt.setString(index++, tokenDimensioneCache);
  1913.                 updateStmt.setString(index++, tokenAlgoritmoCache);
  1914.                 updateStmt.setString(index++, tokenIdleCache);
  1915.                 updateStmt.setString(index++, tokenLifeCache);
  1916.                 // aa cache
  1917.                 updateStmt.setString(index++, aaStatoCache);
  1918.                 updateStmt.setString(index++, aaDimensioneCache);
  1919.                 updateStmt.setString(index++, aaAlgoritmoCache);
  1920.                 updateStmt.setString(index++, aaIdleCache);
  1921.                 updateStmt.setString(index++, aaLifeCache);
  1922.                 // keystore cache
  1923.                 updateStmt.setString(index++, keystoreStatoCache);
  1924.                 updateStmt.setString(index++, keystoreDimensioneCache);
  1925.                 updateStmt.setString(index++, keystoreAlgoritmoCache);
  1926.                 updateStmt.setString(index++, keystoreIdleCache);
  1927.                 updateStmt.setString(index++, keystoreLifeCache);
  1928.                 updateStmt.setString(index++, keystoreCrlLifeCache);
  1929.                 // multitenant
  1930.                 updateStmt.setString(index++, multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getStato()) : null);
  1931.                 updateStmt.setString(index++, multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getFruizioneSceltaSoggettiErogatori()) : null);
  1932.                 updateStmt.setString(index++, multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getErogazioneSceltaSoggettiFruitori()) : null);
  1933.                 // cors
  1934.                 updateStmt.setString(index++, corsStato);
  1935.                 updateStmt.setString(index++, corsTipo);
  1936.                 updateStmt.setString(index++, corsAllAllowOrigins);
  1937.                 updateStmt.setString(index++, corsAllAllowMethods);
  1938.                 updateStmt.setString(index++, corsAllAllowHeaders);
  1939.                 updateStmt.setString(index++, corsAllowCredentials);
  1940.                 updateStmt.setInt(index++, corsAllowMaxAge);
  1941.                 if(corsAllowMaxAgeSeconds!=null) {
  1942.                     updateStmt.setInt(index++, corsAllowMaxAgeSeconds);
  1943.                 }
  1944.                 else {
  1945.                     updateStmt.setNull(index++, java.sql.Types.INTEGER);
  1946.                 }
  1947.                 updateStmt.setString(index++, corsAllowOrigins);
  1948.                 updateStmt.setString(index++, corsAllowHeaders);
  1949.                 updateStmt.setString(index++, corsAllowMethods);
  1950.                 updateStmt.setString(index++, corsAllowExposeHeaders);              
  1951.                 // responseCaching
  1952.                 updateStmt.setString(index++, responseCacheStato);
  1953.                 if(responseCacheSeconds!=null) {
  1954.                     updateStmt.setInt(index++, responseCacheSeconds);
  1955.                 }
  1956.                 else {
  1957.                     updateStmt.setNull(index++, java.sql.Types.INTEGER);
  1958.                 }
  1959.                 if(responseCacheMaxMsgSize!=null) {
  1960.                     updateStmt.setLong(index++, responseCacheMaxMsgSize);
  1961.                 }
  1962.                 else {
  1963.                     updateStmt.setNull(index++, java.sql.Types.BIGINT);
  1964.                 }
  1965.                 updateStmt.setInt(index++, responseCacheNoCache ? CostantiDB.TRUE : CostantiDB.FALSE);
  1966.                 updateStmt.setInt(index++, responseCacheMaxAge ? CostantiDB.TRUE : CostantiDB.FALSE);
  1967.                 updateStmt.setInt(index++, responseCacheNoStore ? CostantiDB.TRUE : CostantiDB.FALSE);
  1968.                 updateStmt.setString(index++, responseCacheHashUrl);
  1969.                 updateStmt.setString(index++, responseCacheHashQuery);
  1970.                 updateStmt.setString(index++, responseCacheHashQueryList);
  1971.                 updateStmt.setString(index++, responseCacheHashHeaders);
  1972.                 updateStmt.setString(index++, responseCacheHashHeadersList);
  1973.                 updateStmt.setString(index++, responseCacheHashPayload);
  1974.                 // responseCaching cache
  1975.                 updateStmt.setString(index++, responseCachingStatoCache);
  1976.                 updateStmt.setString(index++, responseCachingDimensioneCache);
  1977.                 updateStmt.setString(index++, responseCachingAlgoritmoCache);
  1978.                 updateStmt.setString(index++, responseCachingIdleCache);
  1979.                 updateStmt.setString(index++, responseCachingLifeCache);
  1980.                 // consegna applicativi cache
  1981.                 updateStmt.setString(index++, consegnaStatoCache);
  1982.                 updateStmt.setString(index++, consegnaDimensioneCache);
  1983.                 updateStmt.setString(index++, consegnaAlgoritmoCache);
  1984.                 updateStmt.setString(index++, consegnaIdleCache);
  1985.                 updateStmt.setString(index++, consegnaLifeCache);
  1986.                 // canali
  1987.                 updateStmt.setString(index++, configurazioneCanaliStato);
  1988.                 // dati richieste cache
  1989.                 updateStmt.setString(index++, datiRichiesteStatoCache);
  1990.                 updateStmt.setString(index++, datiRichiesteDimensioneCache);
  1991.                 updateStmt.setString(index++, datiRichiesteAlgoritmoCache);
  1992.                 updateStmt.setString(index++, datiRichiesteIdleCache);
  1993.                 updateStmt.setString(index++, datiRichiesteLifeCache);

  1995.                 String msgDebug = "eseguo query :" + 
  1996.                         DBUtils.formatSQLString(updateQuery, 
  1997.                                 cadenzaInoltro, 
  1998.                                 valStato, valControllo, 
  1999.                                 msgDiagSeverita, msgDiagSeveritaLog4j, 
  2000.                                 autenticazione, 
  2001.                                 valProfiloCollaborazione, 
  2002.                                 modRisposta, utilizzoIndTelematico, 
  2003.                                 routingEnabled, gestioneManifest, 
  2004.                                 valManifest, 
  2005.                                 tracciamentoBuste, 
  2006.                                 tracciamentoEsitiPA, tracciamentoEsitiPD,
  2007.                                 transazioniTempiElaborazionePA, transazioniTempiElaborazionePD, 
  2008.                                 transazioniTokenPA, transazioniTokenPD, 
  2009.                                 dumpApplicativo, dumpPD, dumpPA,
  2010.                                 validazioneContenutiStato,validazioneContenutiTipo,validazioneContenutiAcceptMtomMessage,
  2011.                                 registroStatoCache, registroDimensioneCache, registroAlgoritmoCache, registroIdleCache, registroLifeCache,
  2012.                                 configStatoCache, configDimensioneCache, configAlgoritmoCache, configIdleCache, configLifeCache,
  2013.                                 authzStatoCache, authzDimensioneCache, authzAlgoritmoCache, authzIdleCache, authzLifeCache,
  2014.                                 authnStatoCache, authnDimensioneCache, authnAlgoritmoCache, authnIdleCache, authnLifeCache,
  2015.                                 tokenStatoCache, tokenDimensioneCache, tokenAlgoritmoCache, tokenIdleCache, tokenLifeCache,
  2016.                                 aaStatoCache, aaDimensioneCache, aaAlgoritmoCache, aaIdleCache, aaLifeCache,
  2017.                                 keystoreStatoCache, keystoreDimensioneCache, keystoreAlgoritmoCache, keystoreIdleCache, keystoreLifeCache, keystoreCrlLifeCache,
  2018.                                 (multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getStato()) : null),
  2019.                                 (multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getFruizioneSceltaSoggettiErogatori()) : null),
  2020.                                 (multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getErogazioneSceltaSoggettiFruitori()) : null),
  2021.                                 corsStato, corsTipo, corsAllAllowOrigins, corsAllAllowMethods, corsAllAllowHeaders, corsAllowCredentials, corsAllowMaxAge, corsAllowMaxAgeSeconds,
  2022.                                 corsAllowOrigins, corsAllowHeaders, corsAllowMethods, corsAllowExposeHeaders,
  2023.                                 responseCacheStato, responseCacheSeconds, responseCacheMaxMsgSize, 
  2024.                                 (responseCacheNoCache ? CostantiDB.TRUE : CostantiDB.FALSE),
  2025.                                 (responseCacheMaxAge ? CostantiDB.TRUE : CostantiDB.FALSE),
  2026.                                 (responseCacheNoStore ? CostantiDB.TRUE : CostantiDB.FALSE),
  2027.                                 responseCacheHashUrl, responseCacheHashQuery, responseCacheHashQueryList, responseCacheHashHeaders, responseCacheHashHeadersList, responseCacheHashPayload,
  2028.                                 responseCachingStatoCache, responseCachingDimensioneCache, responseCachingAlgoritmoCache, responseCachingIdleCache, responseCachingLifeCache,
  2029.                                 consegnaStatoCache, consegnaDimensioneCache, consegnaAlgoritmoCache, consegnaIdleCache, consegnaLifeCache,
  2030.                                 configurazioneCanaliStato,
  2031.                                 datiRichiesteStatoCache, datiRichiesteDimensioneCache, datiRichiesteAlgoritmoCache, datiRichiesteIdleCache, datiRichiesteLifeCache
  2032.                                 );
  2033.                 DriverConfigurazioneDBLib.logDebug(msgDebug);

  2035.                 n = updateStmt.executeUpdate();
  2036.                 updateStmt.close();

  2038.                 // delete from config_url_invocazione
  2039.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2040.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_URL_REGOLE);
  2041.                 updateQuery = sqlQueryObject.createSQLDelete();
  2042.                 updateStmt = con.prepareStatement(updateQuery);
  2043.                 updateStmt.executeUpdate();
  2044.                 updateStmt.close();
  2045.                 
  2046.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2047.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_URL_INVOCAZIONE);
  2048.                 updateQuery = sqlQueryObject.createSQLDelete();
  2049.                 updateStmt = con.prepareStatement(updateQuery);
  2050.                 updateStmt.executeUpdate();
  2051.                 updateStmt.close();
  2052.                 
  2053.                 // insert into config_protocolli
  2054.                 if(config.getUrlInvocazione()!=null){
  2055.                     
  2056.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2057.                     sqlQueryObject.addInsertTable(CostantiDB.CONFIG_URL_INVOCAZIONE);
  2058.                     sqlQueryObject.addInsertField("base_url", "?");
  2059.                     sqlQueryObject.addInsertField("base_url_fruizione", "?");
  2060.                     updateQuery = sqlQueryObject.createSQLInsert();
  2061.                     updateStmt = con.prepareStatement(updateQuery);
  2062.                     int indexP = 1;
  2063.                     updateStmt.setString(indexP++, config.getUrlInvocazione().getBaseUrl());
  2064.                     updateStmt.setString(indexP++, config.getUrlInvocazione().getBaseUrlFruizione());
  2065.                     updateStmt.executeUpdate();
  2066.                     updateStmt.close();
  2067.                     
  2068.                     if(config.getUrlInvocazione().sizeRegolaList()>0){
  2069.                         for(int k=0; k<config.getUrlInvocazione().sizeRegolaList();k++){
  2070.                             ConfigurazioneUrlInvocazioneRegola configUrlInvocazioneRegola = config.getUrlInvocazione().getRegola(k);
  2071.                             createUrlInvocazioneRegolaEngine(configUrlInvocazioneRegola, con);
  2072.                         }
  2073.                     }
  2074.                 }
  2075.                 
  2076.                 // delete from msg diag appender
  2077.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2078.                 sqlQueryObject.addDeleteTable(CostantiDB.MSG_DIAGN_APPENDER_PROP);
  2079.                 updateQuery = sqlQueryObject.createSQLDelete();
  2080.                 updateStmt = con.prepareStatement(updateQuery);
  2081.                 updateStmt.executeUpdate();
  2082.                 updateStmt.close();

  2084.                 // delete from msg diag appender
  2085.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2086.                 sqlQueryObject.addDeleteTable(CostantiDB.MSG_DIAGN_APPENDER);
  2087.                 updateQuery = sqlQueryObject.createSQLDelete();
  2088.                 updateStmt = con.prepareStatement(updateQuery);
  2089.                 updateStmt.executeUpdate();
  2090.                 updateStmt.close();

  2092.                 // insert into msg diag appender
  2093.                 if(config.getMessaggiDiagnostici()!=null){
  2094.                     for(int k=0; k<config.getMessaggiDiagnostici().sizeOpenspcoopAppenderList();k++){
  2095.                         OpenspcoopAppender appender = config.getMessaggiDiagnostici().getOpenspcoopAppender(k);
  2096.                         
  2097.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  2098.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo", appender.getTipo() , InsertAndGeneratedKeyJDBCType.STRING) );
  2099.                         
  2100.                         long idMsgDiagAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  2101.                                 new CustomKeyGeneratorObject(CostantiDB.MSG_DIAGN_APPENDER, CostantiDB.MSG_DIAGN_APPENDER_COLUMN_ID, 
  2102.                                         CostantiDB.MSG_DIAGN_APPENDER_SEQUENCE, CostantiDB.MSG_DIAGN_APPENDER_TABLE_FOR_ID),
  2103.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  2104.                         if(idMsgDiagAppender<=0){
  2105.                             throw new DriverConfigurazioneException("ID (msg diag appender) autoincrementale non ottenuto");
  2106.                         }
  2107.                         
  2108.                         for(int l=0; l<appender.sizePropertyList();l++){
  2109.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2110.                             sqlQueryObject.addInsertTable(CostantiDB.MSG_DIAGN_APPENDER_PROP);
  2111.                             sqlQueryObject.addInsertField("id_appender", "?");
  2112.                             sqlQueryObject.addInsertField("nome", "?");
  2113.                             sqlQueryObject.addInsertField("valore", "?");
  2114.                             updateQuery = sqlQueryObject.createSQLInsert();
  2115.                             updateStmt = con.prepareStatement(updateQuery);
  2116.                             updateStmt.setLong(1, idMsgDiagAppender);
  2117.                             updateStmt.setString(2, appender.getProperty(l).getNome());
  2118.                             updateStmt.setString(3, appender.getProperty(l).getValore());
  2119.                             updateStmt.executeUpdate();
  2120.                             updateStmt.close();
  2121.                         }

  2123.                     }
  2124.                 }

  2126.                 // delete from tracciamento appender
  2127.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2128.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_APPENDER_PROP);
  2129.                 updateQuery = sqlQueryObject.createSQLDelete();
  2130.                 updateStmt = con.prepareStatement(updateQuery);
  2131.                 updateStmt.executeUpdate();
  2132.                 updateStmt.close();

  2134.                 // delete from tracciamento appender
  2135.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2136.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_APPENDER);
  2137.                 updateQuery = sqlQueryObject.createSQLDelete();
  2138.                 updateStmt = con.prepareStatement(updateQuery);
  2139.                 updateStmt.executeUpdate();
  2140.                 updateStmt.close();

  2142.                 // insert into tracciamento appender
  2143.                 if(config.getTracciamento()!=null){
  2144.                     for(int k=0; k<config.getTracciamento().sizeOpenspcoopAppenderList();k++){
  2145.                         OpenspcoopAppender appender = config.getTracciamento().getOpenspcoopAppender(k);
  2146.                         
  2147.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  2148.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo", appender.getTipo() , InsertAndGeneratedKeyJDBCType.STRING) );
  2149.                         
  2150.                         long idTracceAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  2151.                                 new CustomKeyGeneratorObject(CostantiDB.TRACCIAMENTO_APPENDER, CostantiDB.TRACCIAMENTO_APPENDER_COLUMN_ID, 
  2152.                                         CostantiDB.TRACCIAMENTO_APPENDER_SEQUENCE, CostantiDB.TRACCIAMENTO_APPENDER_TABLE_FOR_ID),
  2153.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  2154.                         if(idTracceAppender<=0){
  2155.                             throw new DriverConfigurazioneException("ID (tracce appender) autoincrementale non ottenuto");
  2156.                         }

  2158.                         for(int l=0; l<appender.sizePropertyList();l++){
  2159.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2160.                             sqlQueryObject.addInsertTable(CostantiDB.TRACCIAMENTO_APPENDER_PROP);
  2161.                             sqlQueryObject.addInsertField("id_appender", "?");
  2162.                             sqlQueryObject.addInsertField("nome", "?");
  2163.                             sqlQueryObject.addInsertField("valore", "?");
  2164.                             updateQuery = sqlQueryObject.createSQLInsert();
  2165.                             updateStmt = con.prepareStatement(updateQuery);
  2166.                             updateStmt.setLong(1, idTracceAppender);
  2167.                             updateStmt.setString(2, appender.getProperty(l).getNome());
  2168.                             updateStmt.setString(3, appender.getProperty(l).getValore());
  2169.                             updateStmt.executeUpdate();
  2170.                             updateStmt.close();
  2171.                         }

  2173.                     }
  2174.                 }
  2175.                 
  2176.                 
  2177.                 // tracciamentoConfigurazione
  2178.                 
  2179.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneDatabasePA, null, 
  2180.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA,
  2181.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  2182.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneDatabasePD, null, 
  2183.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD,
  2184.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  2185.                 
  2186.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneFiletracePA, null, 
  2187.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA,
  2188.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  2189.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneFiletracePD, null, 
  2190.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD,
  2191.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  2192.                 
  2193.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoConfigurazioneFiletraceDetailsPA, null, 
  2194.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  2195.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoConfigurazioneFiletraceDetailsPD, null, 
  2196.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  2197.                 
  2198.                 
  2199.                 
  2200.                 
  2201.                 
  2202.                 // delete from dump appender_prop
  2203.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2204.                 sqlQueryObject.addDeleteTable(CostantiDB.DUMP_APPENDER_PROP);
  2205.                 updateQuery = sqlQueryObject.createSQLDelete();
  2206.                 updateStmt = con.prepareStatement(updateQuery);
  2207.                 updateStmt.executeUpdate();
  2208.                 updateStmt.close();

  2210.                 // delete from dump appender
  2211.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2212.                 sqlQueryObject.addDeleteTable(CostantiDB.DUMP_APPENDER);
  2213.                 updateQuery = sqlQueryObject.createSQLDelete();
  2214.                 updateStmt = con.prepareStatement(updateQuery);
  2215.                 updateStmt.executeUpdate();
  2216.                 updateStmt.close();

  2218.                 // insert into dump appender
  2219.                 if(config.getDump()!=null){
  2220.                     for(int k=0; k<config.getDump().sizeOpenspcoopAppenderList();k++){
  2221.                         OpenspcoopAppender appender = config.getDump().getOpenspcoopAppender(k);
  2222.                         
  2223.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  2224.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo", appender.getTipo() , InsertAndGeneratedKeyJDBCType.STRING) );
  2225.                         
  2226.                         long idDumpAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  2227.                                 new CustomKeyGeneratorObject(CostantiDB.DUMP_APPENDER, CostantiDB.DUMP_APPENDER_COLUMN_ID, 
  2228.                                         CostantiDB.DUMP_APPENDER_SEQUENCE, CostantiDB.DUMP_APPENDER_TABLE_FOR_ID),
  2229.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  2230.                         if(idDumpAppender<=0){
  2231.                             throw new DriverConfigurazioneException("ID (dump appender) autoincrementale non ottenuto");
  2232.                         }

  2234.                         for(int l=0; l<appender.sizePropertyList();l++){
  2235.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2236.                             sqlQueryObject.addInsertTable(CostantiDB.DUMP_APPENDER_PROP);
  2237.                             sqlQueryObject.addInsertField("id_appender", "?");
  2238.                             sqlQueryObject.addInsertField("nome", "?");
  2239.                             sqlQueryObject.addInsertField("valore", "?");
  2240.                             updateQuery = sqlQueryObject.createSQLInsert();
  2241.                             updateStmt = con.prepareStatement(updateQuery);
  2242.                             updateStmt.setLong(1, idDumpAppender);
  2243.                             updateStmt.setString(2, appender.getProperty(l).getNome());
  2244.                             updateStmt.setString(3, appender.getProperty(l).getValore());
  2245.                             updateStmt.executeUpdate();
  2246.                             updateStmt.close();
  2247.                         }

  2249.                     }
  2250.                 }
  2251.                 
  2252.                                 
  2253.                 // Cache Regole
  2254.                 n=0;
  2255.                 if(responseCacheRegole!=null && !responseCacheRegole.isEmpty()){
  2256.                     for (int j = 0; j < responseCacheRegole.size(); j++) {
  2257.                         ResponseCachingConfigurazioneRegola regola = responseCacheRegole.get(j);
  2258.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2259.                         sqlQueryObject.addInsertTable(CostantiDB.CONFIGURAZIONE_CACHE_REGOLE);
  2260.                         if(regola.getReturnCodeMin()!=null && regola.getReturnCodeMin()>0) {
  2261.                             sqlQueryObject.addInsertField("status_min", "?");
  2262.                         }
  2263.                         if(regola.getReturnCodeMax()!=null && regola.getReturnCodeMax()>0) {
  2264.                             sqlQueryObject.addInsertField("status_max", "?");
  2265.                         }
  2266.                         sqlQueryObject.addInsertField("fault", "?");
  2267.                         if(regola.getCacheTimeoutSeconds()!=null && regola.getCacheTimeoutSeconds()>0) {
  2268.                             sqlQueryObject.addInsertField("cache_seconds", "?");
  2269.                         }
  2270.                         String sqlQuery = sqlQueryObject.createSQLInsert();
  2271.                         updateStmt = con.prepareStatement(sqlQuery);
  2272.                         int indexCR = 1;
  2273.                         if(regola.getReturnCodeMin()!=null && regola.getReturnCodeMin()>0) {
  2274.                             updateStmt.setInt(indexCR++, regola.getReturnCodeMin());
  2275.                         }
  2276.                         if(regola.getReturnCodeMax()!=null && regola.getReturnCodeMax()>0) {
  2277.                             updateStmt.setInt(indexCR++, regola.getReturnCodeMax());
  2278.                         }
  2279.                         updateStmt.setInt(indexCR++, regola.getFault() ? CostantiDB.TRUE : CostantiDB.FALSE);
  2280.                         if(regola.getCacheTimeoutSeconds()!=null && regola.getCacheTimeoutSeconds()>0) {
  2281.                             updateStmt.setInt(indexCR++, regola.getCacheTimeoutSeconds());
  2282.                         }
  2283.                         updateStmt.executeUpdate();
  2284.                         updateStmt.close();
  2285.                         n++;
  2286.                         DriverConfigurazioneDBLib.logDebug("Aggiunta regola di cache");
  2287.                     }
  2288.                 }
  2289.                 
  2290.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " regole di cache");
  2291.                 
  2292.                 // dumpConfigurazione
  2293.                 
  2294.                 // per backward compatibility elimino una config esistente
  2295.                 DumpConfigurazione dumpConfigOldBackwardCompatibility = DriverConfigurazioneDB_dumpLIB.readDumpConfigurazione(con, null, CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG);
  2296.                 if(dumpConfigOldBackwardCompatibility!=null) {
  2297.                     DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(DELETE, con, dumpConfigOldBackwardCompatibility, null, CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG);
  2298.                 }
  2299.                 
  2300.                 DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(type, con, dumpConfigPA, null, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  2301.                 DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(type, con, dumpConfigPD, null, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  2302.                 

  2304.                 // delete from msgdiag ds prop
  2305.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2306.                 sqlQueryObject.addDeleteTable(CostantiDB.MSG_DIAGN_DS_PROP);
  2307.                 updateQuery = sqlQueryObject.createSQLDelete();
  2308.                 updateStmt = con.prepareStatement(updateQuery);
  2309.                 updateStmt.executeUpdate();
  2310.                 updateStmt.close();

  2312.                 // delete from msgdiag ds
  2313.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2314.                 sqlQueryObject.addDeleteTable(CostantiDB.MSG_DIAGN_DS);
  2315.                 updateQuery = sqlQueryObject.createSQLDelete();
  2316.                 updateStmt = con.prepareStatement(updateQuery);
  2317.                 updateStmt.executeUpdate();
  2318.                 updateStmt.close();

  2320.                 // insert into msgdiag ds
  2321.                 if(config.getMessaggiDiagnostici()!=null){
  2322.                     for(int k=0; k<config.getMessaggiDiagnostici().sizeOpenspcoopSorgenteDatiList();k++){
  2323.                         OpenspcoopSorgenteDati ds = config.getMessaggiDiagnostici().getOpenspcoopSorgenteDati(k);
  2324.                         
  2325.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  2326.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome", ds.getNome() , InsertAndGeneratedKeyJDBCType.STRING) );
  2327.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome_jndi", ds.getNomeJndi() , InsertAndGeneratedKeyJDBCType.STRING) );
  2328.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo_database", ds.getTipoDatabase() , InsertAndGeneratedKeyJDBCType.STRING) );
  2329.                         
  2330.                         long idMsgDsAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  2331.                                 new CustomKeyGeneratorObject(CostantiDB.MSG_DIAGN_DS, CostantiDB.MSG_DIAGN_DS_COLUMN_ID, 
  2332.                                         CostantiDB.MSG_DIAGN_DS_SEQUENCE, CostantiDB.MSG_DIAGN_DS_TABLE_FOR_ID),
  2333.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  2334.                         if(idMsgDsAppender<=0){
  2335.                             throw new DriverConfigurazioneException("ID (msgdiag ds appender) autoincrementale non ottenuto");
  2336.                         }

  2338.                         for(int l=0; l<ds.sizePropertyList();l++){
  2339.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2340.                             sqlQueryObject.addInsertTable(CostantiDB.MSG_DIAGN_DS_PROP);
  2341.                             sqlQueryObject.addInsertField("id_prop", "?");
  2342.                             sqlQueryObject.addInsertField("nome", "?");
  2343.                             sqlQueryObject.addInsertField("valore", "?");
  2344.                             updateQuery = sqlQueryObject.createSQLInsert();
  2345.                             updateStmt = con.prepareStatement(updateQuery);
  2346.                             updateStmt.setLong(1, idMsgDsAppender);
  2347.                             updateStmt.setString(2, ds.getProperty(l).getNome());
  2348.                             updateStmt.setString(3, ds.getProperty(l).getValore());
  2349.                             updateStmt.executeUpdate();
  2350.                             updateStmt.close();
  2351.                         }

  2353.                     }
  2354.                 }

  2356.                 // delete from tracce ds prop
  2357.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2358.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_DS_PROP);
  2359.                 updateQuery = sqlQueryObject.createSQLDelete();
  2360.                 updateStmt = con.prepareStatement(updateQuery);
  2361.                 updateStmt.executeUpdate();
  2362.                 updateStmt.close();

  2364.                 // delete from tracce ds
  2365.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2366.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_DS);
  2367.                 updateQuery = sqlQueryObject.createSQLDelete();
  2368.                 updateStmt = con.prepareStatement(updateQuery);
  2369.                 updateStmt.executeUpdate();
  2370.                 updateStmt.close();

  2372.                 // insert into tracce ds
  2373.                 if(config.getTracciamento()!=null){
  2374.                     for(int k=0; k<config.getTracciamento().sizeOpenspcoopSorgenteDatiList();k++){
  2375.                         OpenspcoopSorgenteDati ds = config.getTracciamento().getOpenspcoopSorgenteDati(k);
  2376.                         
  2377.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  2378.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome", ds.getNome() , InsertAndGeneratedKeyJDBCType.STRING) );
  2379.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome_jndi", ds.getNomeJndi() , InsertAndGeneratedKeyJDBCType.STRING) );
  2380.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo_database", ds.getTipoDatabase() , InsertAndGeneratedKeyJDBCType.STRING) );
  2381.                         
  2382.                         long idTracceDsAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  2383.                                 new CustomKeyGeneratorObject(CostantiDB.TRACCIAMENTO_DS, CostantiDB.TRACCIAMENTO_DS_COLUMN_ID, 
  2384.                                         CostantiDB.TRACCIAMENTO_DS_SEQUENCE, CostantiDB.TRACCIAMENTO_DS_TABLE_FOR_ID),
  2385.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  2386.                         if(idTracceDsAppender<=0){
  2387.                             throw new DriverConfigurazioneException("ID (tracciamento ds appender) autoincrementale non ottenuto");
  2388.                         }

  2390.                         for(int l=0; l<ds.sizePropertyList();l++){
  2391.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2392.                             sqlQueryObject.addInsertTable(CostantiDB.TRACCIAMENTO_DS_PROP);
  2393.                             sqlQueryObject.addInsertField("id_prop", "?");
  2394.                             sqlQueryObject.addInsertField("nome", "?");
  2395.                             sqlQueryObject.addInsertField("valore", "?");
  2396.                             updateQuery = sqlQueryObject.createSQLInsert();
  2397.                             updateStmt = con.prepareStatement(updateQuery);
  2398.                             updateStmt.setLong(1, idTracceDsAppender);
  2399.                             updateStmt.setString(2, ds.getProperty(l).getNome());
  2400.                             updateStmt.setString(3, ds.getProperty(l).getValore());
  2401.                             updateStmt.executeUpdate();
  2402.                             updateStmt.close();
  2403.                         }

  2405.                     }
  2406.                 }
  2407.                 
  2408.                 // canali
  2409.                 if(configurazioneCanali!=null) {
  2410.                     DriverConfigurazioneDB_canaliLIB.CRUDCanaliConfigurazione(type, con, configurazioneCanali);
  2411.                 }
  2412.                 
  2413.                 // handlers
  2414.                 if(configHandlers!=null) {
  2415.                     if(configHandlers.getRequest()!=null) {
  2416.                         DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, null, null, true, configHandlers.getRequest());
  2417.                     }
  2418.                     if(configHandlers.getResponse()!=null) {
  2419.                         DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, null, null, false, configHandlers.getResponse());
  2420.                     }
  2421.                     if(configHandlers.getService()!=null) {
  2422.                         DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneServiceHandlers(type, con, null, null, false, configHandlers.getService());
  2423.                     }
  2424.                 }
  2425.                 
  2426.                 // ExtendedInfo
  2427.                 if(extInfoConfigurazioneDriver!=null &&         
  2428.                     config.sizeExtendedInfoList()>0){
  2429.                     for(int l=0; l<config.sizeExtendedInfoList();l++){
  2430.                         extInfoConfigurazioneDriver.deleteExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), CRUDType.CREATE);
  2431.                         extInfoConfigurazioneDriver.createExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), CRUDType.CREATE);
  2432.                     }
  2433.                 }


  2436.                 break;
  2437.             case UPDATE:
  2438.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2439.                 sqlQueryObject.addUpdateTable(CostantiDB.CONFIGURAZIONE);
  2440.                 sqlQueryObject.addUpdateField("cadenza_inoltro", "?");
  2441.                 sqlQueryObject.addUpdateField("validazione_stato", "?");
  2442.                 sqlQueryObject.addUpdateField("validazione_controllo", "?");
  2443.                 sqlQueryObject.addUpdateField("msg_diag_severita", "?");
  2444.                 sqlQueryObject.addUpdateField("msg_diag_severita_log4j", "?");
  2445.                 sqlQueryObject.addUpdateField("auth_integration_manager", "?");
  2446.                 sqlQueryObject.addUpdateField("validazione_profilo", "?");
  2447.                 sqlQueryObject.addUpdateField("mod_risposta", "?");
  2448.                 sqlQueryObject.addUpdateField("indirizzo_telematico", "?");
  2449.                 sqlQueryObject.addUpdateField("routing_enabled", "?");
  2450.                 sqlQueryObject.addUpdateField("gestione_manifest", "?");
  2451.                 sqlQueryObject.addUpdateField("validazione_manifest", "?");
  2452.                 sqlQueryObject.addUpdateField("tracciamento_buste", "?");
  2453.                 // tracciamento
  2454.                 sqlQueryObject.addUpdateField("tracciamento_esiti", "?");
  2455.                 sqlQueryObject.addUpdateField("tracciamento_esiti_pd", "?");
  2456.                 sqlQueryObject.addUpdateField("transazioni_tempi", "?");
  2457.                 sqlQueryObject.addUpdateField("transazioni_tempi_pd", "?");
  2458.                 sqlQueryObject.addUpdateField("transazioni_token", "?");
  2459.                 sqlQueryObject.addUpdateField("transazioni_token_pd", "?");
  2460.                 // dump
  2461.                 sqlQueryObject.addUpdateField("dump", "?");
  2462.                 sqlQueryObject.addUpdateField("dump_bin_pd", "?");
  2463.                 sqlQueryObject.addUpdateField("dump_bin_pa", "?");
  2464.                 // validazione
  2465.                 sqlQueryObject.addUpdateField("validazione_contenuti_stato", "?");
  2466.                 sqlQueryObject.addUpdateField("validazione_contenuti_tipo", "?");
  2467.                 sqlQueryObject.addUpdateField("validazione_contenuti_mtom", "?");
  2468.                 // registro cache
  2469.                 sqlQueryObject.addUpdateField("statocache", "?");
  2470.                 sqlQueryObject.addUpdateField("dimensionecache", "?");
  2471.                 sqlQueryObject.addUpdateField("algoritmocache", "?");
  2472.                 sqlQueryObject.addUpdateField("idlecache", "?");
  2473.                 sqlQueryObject.addUpdateField("lifecache", "?");
  2474.                 // config cache
  2475.                 sqlQueryObject.addUpdateField("config_statocache", "?");
  2476.                 sqlQueryObject.addUpdateField("config_dimensionecache", "?");
  2477.                 sqlQueryObject.addUpdateField("config_algoritmocache", "?");
  2478.                 sqlQueryObject.addUpdateField("config_idlecache", "?");
  2479.                 sqlQueryObject.addUpdateField("config_lifecache", "?");
  2480.                 // authz cache
  2481.                 sqlQueryObject.addUpdateField("auth_statocache", "?");
  2482.                 sqlQueryObject.addUpdateField("auth_dimensionecache", "?");
  2483.                 sqlQueryObject.addUpdateField("auth_algoritmocache", "?");
  2484.                 sqlQueryObject.addUpdateField("auth_idlecache", "?");
  2485.                 sqlQueryObject.addUpdateField("auth_lifecache", "?");
  2486.                 // authn cache
  2487.                 sqlQueryObject.addUpdateField("authn_statocache", "?");
  2488.                 sqlQueryObject.addUpdateField("authn_dimensionecache", "?");
  2489.                 sqlQueryObject.addUpdateField("authn_algoritmocache", "?");
  2490.                 sqlQueryObject.addUpdateField("authn_idlecache", "?");
  2491.                 sqlQueryObject.addUpdateField("authn_lifecache", "?");
  2492.                 // token cache
  2493.                 sqlQueryObject.addUpdateField("token_statocache", "?");
  2494.                 sqlQueryObject.addUpdateField("token_dimensionecache", "?");
  2495.                 sqlQueryObject.addUpdateField("token_algoritmocache", "?");
  2496.                 sqlQueryObject.addUpdateField("token_idlecache", "?");
  2497.                 sqlQueryObject.addUpdateField("token_lifecache", "?");
  2498.                 // aa cache
  2499.                 sqlQueryObject.addUpdateField("aa_statocache", "?");
  2500.                 sqlQueryObject.addUpdateField("aa_dimensionecache", "?");
  2501.                 sqlQueryObject.addUpdateField("aa_algoritmocache", "?");
  2502.                 sqlQueryObject.addUpdateField("aa_idlecache", "?");
  2503.                 sqlQueryObject.addUpdateField("aa_lifecache", "?");
  2504.                 // keystore cache
  2505.                 sqlQueryObject.addUpdateField("keystore_statocache", "?");
  2506.                 sqlQueryObject.addUpdateField("keystore_dimensionecache", "?");
  2507.                 sqlQueryObject.addUpdateField("keystore_algoritmocache", "?");
  2508.                 sqlQueryObject.addUpdateField("keystore_idlecache", "?");
  2509.                 sqlQueryObject.addUpdateField("keystore_lifecache", "?");
  2510.                 sqlQueryObject.addUpdateField("keystore_crl_lifecache", "?");
  2511.                 // multitenant
  2512.                 sqlQueryObject.addUpdateField("multitenant_stato", "?");
  2513.                 sqlQueryObject.addUpdateField("multitenant_fruizioni", "?");
  2514.                 sqlQueryObject.addUpdateField("multitenant_erogazioni", "?");
  2515.                 // cors
  2516.                 sqlQueryObject.addUpdateField("cors_stato", "?");
  2517.                 sqlQueryObject.addUpdateField("cors_tipo", "?");
  2518.                 sqlQueryObject.addUpdateField("cors_all_allow_origins", "?");
  2519.                 sqlQueryObject.addUpdateField("cors_all_allow_methods", "?");
  2520.                 sqlQueryObject.addUpdateField("cors_all_allow_headers", "?");
  2521.                 sqlQueryObject.addUpdateField("cors_allow_credentials", "?");
  2522.                 sqlQueryObject.addUpdateField("cors_allow_max_age", "?");
  2523.                 sqlQueryObject.addUpdateField("cors_allow_max_age_seconds", "?");
  2524.                 sqlQueryObject.addUpdateField("cors_allow_origins", "?");
  2525.                 sqlQueryObject.addUpdateField("cors_allow_headers", "?");
  2526.                 sqlQueryObject.addUpdateField("cors_allow_methods", "?");
  2527.                 sqlQueryObject.addUpdateField("cors_allow_expose_headers", "?");
  2528.                 // responseCaching
  2529.                 sqlQueryObject.addUpdateField("response_cache_stato", "?");
  2530.                 sqlQueryObject.addUpdateField("response_cache_seconds", "?");
  2531.                 sqlQueryObject.addUpdateField("response_cache_max_msg_size", "?");
  2532.                 sqlQueryObject.addUpdateField("response_cache_control_nocache", "?");
  2533.                 sqlQueryObject.addUpdateField("response_cache_control_maxage", "?");
  2534.                 sqlQueryObject.addUpdateField("response_cache_control_nostore", "?");
  2535.                 sqlQueryObject.addUpdateField("response_cache_hash_url", "?");
  2536.                 sqlQueryObject.addUpdateField("response_cache_hash_query", "?");
  2537.                 sqlQueryObject.addUpdateField("response_cache_hash_query_list", "?");
  2538.                 sqlQueryObject.addUpdateField("response_cache_hash_headers", "?");
  2539.                 sqlQueryObject.addUpdateField("response_cache_hash_hdr_list", "?");
  2540.                 sqlQueryObject.addUpdateField("response_cache_hash_payload", "?");
  2541.                 // responseCaching cache
  2542.                 sqlQueryObject.addUpdateField("response_cache_statocache", "?");
  2543.                 sqlQueryObject.addUpdateField("response_cache_dimensionecache", "?");
  2544.                 sqlQueryObject.addUpdateField("response_cache_algoritmocache", "?");
  2545.                 sqlQueryObject.addUpdateField("response_cache_idlecache", "?");
  2546.                 sqlQueryObject.addUpdateField("response_cache_lifecache", "?");
  2547.                 // consegna applicativi cache
  2548.                 sqlQueryObject.addUpdateField("consegna_statocache", "?");
  2549.                 sqlQueryObject.addUpdateField("consegna_dimensionecache", "?");
  2550.                 sqlQueryObject.addUpdateField("consegna_algoritmocache", "?");
  2551.                 sqlQueryObject.addUpdateField("consegna_idlecache", "?");
  2552.                 sqlQueryObject.addUpdateField("consegna_lifecache", "?");
  2553.                 // canali
  2554.                 sqlQueryObject.addUpdateField("canali_stato", "?");
  2555.                 // dati richieste cache
  2556.                 sqlQueryObject.addUpdateField("dati_richieste_statocache", "?");
  2557.                 sqlQueryObject.addUpdateField("dati_richieste_dimensionecache", "?");
  2558.                 sqlQueryObject.addUpdateField("dati_richieste_algoritmocache", "?");
  2559.                 sqlQueryObject.addUpdateField("dati_richieste_idlecache", "?");
  2560.                 sqlQueryObject.addUpdateField("dati_richieste_lifecache", "?");

  2562.                 updateQuery = sqlQueryObject.createSQLUpdate();
  2563.                 updateStmt = con.prepareStatement(updateQuery);
  2564.                 
  2565.                 index = 1;
  2566.                 
  2567.                 updateStmt.setString(index++, cadenzaInoltro);
  2568.                 updateStmt.setString(index++, valStato);
  2569.                 updateStmt.setString(index++, valControllo);
  2570.                 updateStmt.setString(index++, msgDiagSeverita);
  2571.                 updateStmt.setString(index++, msgDiagSeveritaLog4j);
  2572.                 updateStmt.setString(index++, autenticazione);
  2573.                 updateStmt.setString(index++, valProfiloCollaborazione);
  2574.                 updateStmt.setString(index++, modRisposta);
  2575.                 updateStmt.setString(index++, utilizzoIndTelematico);
  2576.                 updateStmt.setString(index++, routingEnabled);
  2577.                 updateStmt.setString(index++, gestioneManifest);
  2578.                 updateStmt.setString(index++, valManifest);
  2579.                 updateStmt.setString(index++, tracciamentoBuste);
  2580.                 // tracciamento
  2581.                 updateStmt.setString(index++, tracciamentoEsitiPA);
  2582.                 updateStmt.setString(index++, tracciamentoEsitiPD);
  2583.                 updateStmt.setString(index++, transazioniTempiElaborazionePA);
  2584.                 updateStmt.setString(index++, transazioniTempiElaborazionePD);
  2585.                 updateStmt.setString(index++, transazioniTokenPA);
  2586.                 updateStmt.setString(index++, transazioniTokenPD);
  2587.                 // dump
  2588.                 updateStmt.setString(index++, dumpApplicativo);
  2589.                 updateStmt.setString(index++, dumpPD);
  2590.                 updateStmt.setString(index++, dumpPA);
  2591.                 // validazione
  2592.                 updateStmt.setString(index++, validazioneContenutiStato);
  2593.                 updateStmt.setString(index++, validazioneContenutiTipo);
  2594.                 updateStmt.setString(index++, validazioneContenutiAcceptMtomMessage);
  2595.                 // registro cache
  2596.                 updateStmt.setString(index++, registroStatoCache);
  2597.                 updateStmt.setString(index++, registroDimensioneCache);
  2598.                 updateStmt.setString(index++, registroAlgoritmoCache);
  2599.                 updateStmt.setString(index++, registroIdleCache);
  2600.                 updateStmt.setString(index++, registroLifeCache);
  2601.                 // config cache
  2602.                 updateStmt.setString(index++, configStatoCache);
  2603.                 updateStmt.setString(index++, configDimensioneCache);
  2604.                 updateStmt.setString(index++, configAlgoritmoCache);
  2605.                 updateStmt.setString(index++, configIdleCache);
  2606.                 updateStmt.setString(index++, configLifeCache);
  2607.                 // authz cache
  2608.                 updateStmt.setString(index++, authzStatoCache);
  2609.                 updateStmt.setString(index++, authzDimensioneCache);
  2610.                 updateStmt.setString(index++, authzAlgoritmoCache);
  2611.                 updateStmt.setString(index++, authzIdleCache);
  2612.                 updateStmt.setString(index++, authzLifeCache);
  2613.                 // authn cache
  2614.                 updateStmt.setString(index++, authnStatoCache);
  2615.                 updateStmt.setString(index++, authnDimensioneCache);
  2616.                 updateStmt.setString(index++, authnAlgoritmoCache);
  2617.                 updateStmt.setString(index++, authnIdleCache);
  2618.                 updateStmt.setString(index++, authnLifeCache);
  2619.                 // token cache
  2620.                 updateStmt.setString(index++, tokenStatoCache);
  2621.                 updateStmt.setString(index++, tokenDimensioneCache);
  2622.                 updateStmt.setString(index++, tokenAlgoritmoCache);
  2623.                 updateStmt.setString(index++, tokenIdleCache);
  2624.                 updateStmt.setString(index++, tokenLifeCache);
  2625.                 // aa cache
  2626.                 updateStmt.setString(index++, aaStatoCache);
  2627.                 updateStmt.setString(index++, aaDimensioneCache);
  2628.                 updateStmt.setString(index++, aaAlgoritmoCache);
  2629.                 updateStmt.setString(index++, aaIdleCache);
  2630.                 updateStmt.setString(index++, aaLifeCache);
  2631.                 // keystore cache
  2632.                 updateStmt.setString(index++, keystoreStatoCache);
  2633.                 updateStmt.setString(index++, keystoreDimensioneCache);
  2634.                 updateStmt.setString(index++, keystoreAlgoritmoCache);
  2635.                 updateStmt.setString(index++, keystoreIdleCache);
  2636.                 updateStmt.setString(index++, keystoreLifeCache);
  2637.                 updateStmt.setString(index++, keystoreCrlLifeCache);
  2638.                 // multitenant
  2639.                 updateStmt.setString(index++, multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getStato()) : null);
  2640.                 updateStmt.setString(index++, multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getFruizioneSceltaSoggettiErogatori()) : null);
  2641.                 updateStmt.setString(index++, multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getErogazioneSceltaSoggettiFruitori()) : null);
  2642.                 // cors
  2643.                 updateStmt.setString(index++, corsStato);
  2644.                 updateStmt.setString(index++, corsTipo);
  2645.                 updateStmt.setString(index++, corsAllAllowOrigins);
  2646.                 updateStmt.setString(index++, corsAllAllowMethods);
  2647.                 updateStmt.setString(index++, corsAllAllowHeaders);
  2648.                 updateStmt.setString(index++, corsAllowCredentials);
  2649.                 updateStmt.setInt(index++, corsAllowMaxAge);
  2650.                 if(corsAllowMaxAgeSeconds!=null) {
  2651.                     updateStmt.setInt(index++, corsAllowMaxAgeSeconds);
  2652.                 }
  2653.                 else {
  2654.                     updateStmt.setNull(index++, java.sql.Types.INTEGER);
  2655.                 }
  2656.                 updateStmt.setString(index++, corsAllowOrigins);
  2657.                 updateStmt.setString(index++, corsAllowHeaders);
  2658.                 updateStmt.setString(index++, corsAllowMethods);
  2659.                 updateStmt.setString(index++, corsAllowExposeHeaders);              
  2660.                 // responseCaching
  2661.                 updateStmt.setString(index++, responseCacheStato);
  2662.                 if(responseCacheSeconds!=null) {
  2663.                     updateStmt.setInt(index++, responseCacheSeconds);
  2664.                 }
  2665.                 else {
  2666.                     updateStmt.setNull(index++, java.sql.Types.INTEGER);
  2667.                 }
  2668.                 if(responseCacheMaxMsgSize!=null) {
  2669.                     updateStmt.setLong(index++, responseCacheMaxMsgSize);
  2670.                 }
  2671.                 else {
  2672.                     updateStmt.setNull(index++, java.sql.Types.BIGINT);
  2673.                 }
  2674.                 updateStmt.setInt(index++, responseCacheNoCache ? CostantiDB.TRUE : CostantiDB.FALSE);
  2675.                 updateStmt.setInt(index++, responseCacheMaxAge ? CostantiDB.TRUE : CostantiDB.FALSE);
  2676.                 updateStmt.setInt(index++, responseCacheNoStore ? CostantiDB.TRUE : CostantiDB.FALSE);
  2677.                 updateStmt.setString(index++, responseCacheHashUrl);
  2678.                 updateStmt.setString(index++, responseCacheHashQuery);
  2679.                 updateStmt.setString(index++, responseCacheHashQueryList);
  2680.                 updateStmt.setString(index++, responseCacheHashHeaders);
  2681.                 updateStmt.setString(index++, responseCacheHashHeadersList);
  2682.                 updateStmt.setString(index++, responseCacheHashPayload);
  2683.                 // responseCaching cache
  2684.                 updateStmt.setString(index++, responseCachingStatoCache);
  2685.                 updateStmt.setString(index++, responseCachingDimensioneCache);
  2686.                 updateStmt.setString(index++, responseCachingAlgoritmoCache);
  2687.                 updateStmt.setString(index++, responseCachingIdleCache);
  2688.                 updateStmt.setString(index++, responseCachingLifeCache);
  2689.                 // consegna applicativi cache
  2690.                 updateStmt.setString(index++, consegnaStatoCache);
  2691.                 updateStmt.setString(index++, consegnaDimensioneCache);
  2692.                 updateStmt.setString(index++, consegnaAlgoritmoCache);
  2693.                 updateStmt.setString(index++, consegnaIdleCache);
  2694.                 updateStmt.setString(index++, consegnaLifeCache);
  2695.                 // canali
  2696.                 updateStmt.setString(index++, configurazioneCanaliStato);
  2697.                 // dati richieste cache
  2698.                 updateStmt.setString(index++, datiRichiesteStatoCache);
  2699.                 updateStmt.setString(index++, datiRichiesteDimensioneCache);
  2700.                 updateStmt.setString(index++, datiRichiesteAlgoritmoCache);
  2701.                 updateStmt.setString(index++, datiRichiesteIdleCache);
  2702.                 updateStmt.setString(index++, datiRichiesteLifeCache);
  2703.                 
  2704.                 DriverConfigurazioneDBLib.logDebug("eseguo query :" + 
  2705.                         DBUtils.formatSQLString(updateQuery, 
  2706.                                 cadenzaInoltro, 
  2707.                                 valStato, valControllo, 
  2708.                                 msgDiagSeverita, msgDiagSeveritaLog4j, 
  2709.                                 autenticazione, 
  2710.                                 valProfiloCollaborazione, 
  2711.                                 modRisposta, utilizzoIndTelematico, 
  2712.                                 routingEnabled, gestioneManifest, 
  2713.                                 valManifest, 
  2714.                                 tracciamentoBuste, 
  2715.                                 tracciamentoEsitiPA, tracciamentoEsitiPD,
  2716.                                 transazioniTempiElaborazionePA, transazioniTempiElaborazionePD, 
  2717.                                 transazioniTokenPA, transazioniTokenPD, 
  2718.                                 dumpApplicativo, dumpPD, dumpPA,
  2719.                                 validazioneContenutiStato,validazioneContenutiTipo,
  2720.                                 registroStatoCache, registroDimensioneCache, registroAlgoritmoCache, registroIdleCache, registroLifeCache,
  2721.                                 configStatoCache, configDimensioneCache, configAlgoritmoCache, configIdleCache, configLifeCache,
  2722.                                 authzStatoCache, authzDimensioneCache, authzAlgoritmoCache, authzIdleCache, authzLifeCache,
  2723.                                 authnStatoCache, authnDimensioneCache, authnAlgoritmoCache, authnIdleCache, authnLifeCache,
  2724.                                 tokenStatoCache, tokenDimensioneCache, tokenAlgoritmoCache, tokenIdleCache, tokenLifeCache,
  2725.                                 keystoreStatoCache, keystoreDimensioneCache, keystoreAlgoritmoCache, keystoreIdleCache, keystoreLifeCache, keystoreCrlLifeCache,
  2726.                                 (multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getStato()) : null),
  2727.                                 (multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getFruizioneSceltaSoggettiErogatori()) : null),
  2728.                                 (multitenant!=null ? DriverConfigurazioneDBLib.getValue(multitenant.getErogazioneSceltaSoggettiFruitori()) : null),
  2729.                                 corsStato, corsTipo, corsAllAllowOrigins, corsAllAllowMethods, corsAllAllowHeaders, corsAllowCredentials, corsAllowMaxAge, corsAllowMaxAgeSeconds,
  2730.                                 corsAllowOrigins, corsAllowHeaders, corsAllowMethods, corsAllowExposeHeaders,
  2731.                                 responseCacheStato, responseCacheSeconds, responseCacheMaxMsgSize, 
  2732.                                 responseCacheHashUrl, responseCacheHashQuery, responseCacheHashQueryList, responseCacheHashHeaders, responseCacheHashHeadersList, responseCacheHashPayload,
  2733.                                 responseCachingStatoCache, responseCachingDimensioneCache, responseCachingAlgoritmoCache, responseCachingIdleCache, responseCachingLifeCache,
  2734.                                 consegnaStatoCache, consegnaDimensioneCache, consegnaAlgoritmoCache, consegnaIdleCache, consegnaLifeCache,
  2735.                                 configurazioneCanaliStato,
  2736.                                 datiRichiesteStatoCache, datiRichiesteDimensioneCache, datiRichiesteAlgoritmoCache, datiRichiesteIdleCache, datiRichiesteLifeCache
  2737.                                 ));

  2739.                 n = updateStmt.executeUpdate();
  2740.                 updateStmt.close();

  2742.                 // delete from config_url_invocazione
  2743.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2744.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_URL_REGOLE);
  2745.                 updateQuery = sqlQueryObject.createSQLDelete();
  2746.                 updateStmt = con.prepareStatement(updateQuery);
  2747.                 updateStmt.executeUpdate();
  2748.                 updateStmt.close();
  2749.                 
  2750.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2751.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIG_URL_INVOCAZIONE);
  2752.                 updateQuery = sqlQueryObject.createSQLDelete();
  2753.                 updateStmt = con.prepareStatement(updateQuery);
  2754.                 updateStmt.executeUpdate();
  2755.                 updateStmt.close();
  2756.                 
  2757.                 // insert into config_protocolli
  2758.                 if(config.getUrlInvocazione()!=null){
  2759.                     
  2760.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2761.                     sqlQueryObject.addInsertTable(CostantiDB.CONFIG_URL_INVOCAZIONE);
  2762.                     sqlQueryObject.addInsertField("base_url", "?");
  2763.                     sqlQueryObject.addInsertField("base_url_fruizione", "?");
  2764.                     updateQuery = sqlQueryObject.createSQLInsert();
  2765.                     updateStmt = con.prepareStatement(updateQuery);
  2766.                     int indexP = 1;
  2767.                     updateStmt.setString(indexP++, config.getUrlInvocazione().getBaseUrl());
  2768.                     updateStmt.setString(indexP++, config.getUrlInvocazione().getBaseUrlFruizione());
  2769.                     updateStmt.executeUpdate();
  2770.                     updateStmt.close();
  2771.                     
  2772.                     if(config.getUrlInvocazione().sizeRegolaList()>0){
  2773.                         for(int k=0; k<config.getUrlInvocazione().sizeRegolaList();k++){
  2774.                             ConfigurazioneUrlInvocazioneRegola configUrlInvocazioneRegola = config.getUrlInvocazione().getRegola(k);
  2775.                             createUrlInvocazioneRegolaEngine(configUrlInvocazioneRegola, con);
  2776.                         }
  2777.                     }
  2778.                 }
  2779.                 
  2780.                 // delete from msg diag appender
  2781.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2782.                 sqlQueryObject.addDeleteTable(CostantiDB.MSG_DIAGN_APPENDER_PROP);
  2783.                 updateQuery = sqlQueryObject.createSQLDelete();
  2784.                 updateStmt = con.prepareStatement(updateQuery);
  2785.                 updateStmt.executeUpdate();
  2786.                 updateStmt.close();

  2788.                 // delete from msg diag appender
  2789.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2790.                 sqlQueryObject.addDeleteTable(CostantiDB.MSG_DIAGN_APPENDER);
  2791.                 updateQuery = sqlQueryObject.createSQLDelete();
  2792.                 updateStmt = con.prepareStatement(updateQuery);
  2793.                 updateStmt.executeUpdate();
  2794.                 updateStmt.close();

  2796.                 // insert into msg diag appender
  2797.                 if(config.getMessaggiDiagnostici()!=null){
  2798.                     for(int k=0; k<config.getMessaggiDiagnostici().sizeOpenspcoopAppenderList();k++){
  2799.                         OpenspcoopAppender appender = config.getMessaggiDiagnostici().getOpenspcoopAppender(k);
  2800.                         
  2801.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  2802.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo", appender.getTipo() , InsertAndGeneratedKeyJDBCType.STRING) );
  2803.                         
  2804.                         long idMsgDiagAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  2805.                                 new CustomKeyGeneratorObject(CostantiDB.MSG_DIAGN_APPENDER, CostantiDB.MSG_DIAGN_APPENDER_COLUMN_ID, 
  2806.                                         CostantiDB.MSG_DIAGN_APPENDER_SEQUENCE, CostantiDB.MSG_DIAGN_APPENDER_TABLE_FOR_ID),
  2807.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  2808.                         if(idMsgDiagAppender<=0){
  2809.                             throw new DriverConfigurazioneException("ID (msg diag appender) autoincrementale non ottenuto");
  2810.                         }

  2812.                         for(int l=0; l<appender.sizePropertyList();l++){
  2813.                             DriverConfigurazioneDBLib.logDebug("INSERT INTO "+CostantiDB.MSG_DIAGN_APPENDER_PROP+" (id_appender,nome,valore) VALUES ("+idMsgDiagAppender+","+appender.getProperty(l).getNome()+","+appender.getProperty(l).getValore()+")");
  2814.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2815.                             sqlQueryObject.addInsertTable(CostantiDB.MSG_DIAGN_APPENDER_PROP);
  2816.                             sqlQueryObject.addInsertField("id_appender", "?");
  2817.                             sqlQueryObject.addInsertField("nome", "?");
  2818.                             sqlQueryObject.addInsertField("valore", "?");
  2819.                             updateQuery = sqlQueryObject.createSQLInsert();
  2820.                             updateStmt = con.prepareStatement(updateQuery);
  2821.                             updateStmt.setLong(1, idMsgDiagAppender);
  2822.                             updateStmt.setString(2, appender.getProperty(l).getNome());
  2823.                             updateStmt.setString(3, appender.getProperty(l).getValore());
  2824.                             updateStmt.executeUpdate();
  2825.                             updateStmt.close();
  2826.                         }

  2828.                     }
  2829.                 }

  2831.                 // delete from tracciamento appender
  2832.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2833.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_APPENDER_PROP);
  2834.                 updateQuery = sqlQueryObject.createSQLDelete();
  2835.                 updateStmt = con.prepareStatement(updateQuery);
  2836.                 updateStmt.executeUpdate();
  2837.                 updateStmt.close();

  2839.                 // delete from tracciamento appender
  2840.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2841.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_APPENDER);
  2842.                 updateQuery = sqlQueryObject.createSQLDelete();
  2843.                 updateStmt = con.prepareStatement(updateQuery);
  2844.                 updateStmt.executeUpdate();
  2845.                 updateStmt.close();

  2847.                 // insert into tracciamento appender
  2848.                 if(config.getTracciamento()!=null){
  2849.                     for(int k=0; k<config.getTracciamento().sizeOpenspcoopAppenderList();k++){
  2850.                         OpenspcoopAppender appender = config.getTracciamento().getOpenspcoopAppender(k);
  2851.                         
  2852.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  2853.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo", appender.getTipo() , InsertAndGeneratedKeyJDBCType.STRING) );
  2854.                         
  2855.                         long idTracceAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  2856.                                 new CustomKeyGeneratorObject(CostantiDB.TRACCIAMENTO_APPENDER, CostantiDB.TRACCIAMENTO_APPENDER_COLUMN_ID, 
  2857.                                         CostantiDB.TRACCIAMENTO_APPENDER_SEQUENCE, CostantiDB.TRACCIAMENTO_APPENDER_TABLE_FOR_ID),
  2858.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  2859.                         if(idTracceAppender<=0){
  2860.                             throw new DriverConfigurazioneException("ID (tracce appender) autoincrementale non ottenuto");
  2861.                         }

  2863.                         for(int l=0; l<appender.sizePropertyList();l++){
  2864.                             DriverConfigurazioneDBLib.logDebug("INSERT INTO "+CostantiDB.TRACCIAMENTO_APPENDER_PROP+" (id_appender,nome,valore) VALUES ("+idTracceAppender+","+appender.getProperty(l).getNome()+","+appender.getProperty(l).getValore()+")");
  2865.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2866.                             sqlQueryObject.addInsertTable(CostantiDB.TRACCIAMENTO_APPENDER_PROP);
  2867.                             sqlQueryObject.addInsertField("id_appender", "?");
  2868.                             sqlQueryObject.addInsertField("nome", "?");
  2869.                             sqlQueryObject.addInsertField("valore", "?");
  2870.                             updateQuery = sqlQueryObject.createSQLInsert();
  2871.                             updateStmt = con.prepareStatement(updateQuery);
  2872.                             updateStmt.setLong(1, idTracceAppender);
  2873.                             updateStmt.setString(2, appender.getProperty(l).getNome());
  2874.                             updateStmt.setString(3, appender.getProperty(l).getValore());
  2875.                             updateStmt.executeUpdate();
  2876.                             updateStmt.close();
  2877.                         }

  2879.                     }
  2880.                 }
  2881.                 
  2882.                 
  2883.                 // tracciamentoConfigurazione
  2884.                 
  2885.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneDatabasePA, null, 
  2886.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA,
  2887.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  2888.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneDatabasePD, null, 
  2889.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD,
  2890.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  2891.                 
  2892.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneFiletracePA, null, 
  2893.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA,
  2894.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  2895.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneFiletracePD, null, 
  2896.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD,
  2897.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  2898.                 
  2899.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoConfigurazioneFiletraceDetailsPA, null, 
  2900.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  2901.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoConfigurazioneFiletraceDetailsPD, null, 
  2902.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  2903.                 
  2904.     
  2905.                 // delete from dump appender_prop
  2906.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2907.                 sqlQueryObject.addDeleteTable(CostantiDB.DUMP_APPENDER_PROP);
  2908.                 updateQuery = sqlQueryObject.createSQLDelete();
  2909.                 updateStmt = con.prepareStatement(updateQuery);
  2910.                 updateStmt.executeUpdate();
  2911.                 updateStmt.close();

  2913.                 // delete from dump appender
  2914.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2915.                 sqlQueryObject.addDeleteTable(CostantiDB.DUMP_APPENDER);
  2916.                 updateQuery = sqlQueryObject.createSQLDelete();
  2917.                 updateStmt = con.prepareStatement(updateQuery);
  2918.                 updateStmt.executeUpdate();
  2919.                 updateStmt.close();

  2921.                 // insert into dump appender
  2922.                 if(config.getDump()!=null){
  2923.                     for(int k=0; k<config.getDump().sizeOpenspcoopAppenderList();k++){
  2924.                         OpenspcoopAppender appender = config.getDump().getOpenspcoopAppender(k);
  2925.                         
  2926.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  2927.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo", appender.getTipo() , InsertAndGeneratedKeyJDBCType.STRING) );
  2928.                         
  2929.                         long idDumpAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  2930.                                 new CustomKeyGeneratorObject(CostantiDB.DUMP_APPENDER, CostantiDB.DUMP_APPENDER_COLUMN_ID, 
  2931.                                         CostantiDB.DUMP_APPENDER_SEQUENCE, CostantiDB.DUMP_APPENDER_TABLE_FOR_ID),
  2932.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  2933.                         if(idDumpAppender<=0){
  2934.                             throw new DriverConfigurazioneException("ID (dump appender) autoincrementale non ottenuto");
  2935.                         }

  2937.                         for(int l=0; l<appender.sizePropertyList();l++){
  2938.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2939.                             sqlQueryObject.addInsertTable(CostantiDB.DUMP_APPENDER_PROP);
  2940.                             sqlQueryObject.addInsertField("id_appender", "?");
  2941.                             sqlQueryObject.addInsertField("nome", "?");
  2942.                             sqlQueryObject.addInsertField("valore", "?");
  2943.                             updateQuery = sqlQueryObject.createSQLInsert();
  2944.                             updateStmt = con.prepareStatement(updateQuery);
  2945.                             updateStmt.setLong(1, idDumpAppender);
  2946.                             updateStmt.setString(2, appender.getProperty(l).getNome());
  2947.                             updateStmt.setString(3, appender.getProperty(l).getValore());
  2948.                             updateStmt.executeUpdate();
  2949.                             updateStmt.close();
  2950.                         }

  2952.                     }
  2953.                 }
  2954.                 
  2955.                 // Cache Regole
  2956.                 
  2957.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2958.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIGURAZIONE_CACHE_REGOLE);
  2959.                 String sqlQuery = sqlQueryObject.createSQLDelete();
  2960.                 updateStmt = con.prepareStatement(sqlQuery);
  2961.                 n=updateStmt.executeUpdate();
  2962.                 updateStmt.close();
  2963.                 DriverConfigurazioneDBLib.logDebug("Cancellati "+n+" regole di cache");
  2964.                 
  2965.                 n=0;
  2966.                 if(responseCacheRegole!=null && !responseCacheRegole.isEmpty()){
  2967.                     for (int j = 0; j < responseCacheRegole.size(); j++) {
  2968.                         ResponseCachingConfigurazioneRegola regola = responseCacheRegole.get(j);
  2969.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  2970.                         sqlQueryObject.addInsertTable(CostantiDB.CONFIGURAZIONE_CACHE_REGOLE);
  2971.                         if(regola.getReturnCodeMin()!=null && regola.getReturnCodeMin()>0) {
  2972.                             sqlQueryObject.addInsertField("status_min", "?");
  2973.                         }
  2974.                         if(regola.getReturnCodeMax()!=null && regola.getReturnCodeMax()>0) {
  2975.                             sqlQueryObject.addInsertField("status_max", "?");
  2976.                         }
  2977.                         sqlQueryObject.addInsertField("fault", "?");
  2978.                         if(regola.getCacheTimeoutSeconds()!=null && regola.getCacheTimeoutSeconds()>0) {
  2979.                             sqlQueryObject.addInsertField("cache_seconds", "?");
  2980.                         }
  2981.                         sqlQuery = sqlQueryObject.createSQLInsert();
  2982.                         updateStmt = con.prepareStatement(sqlQuery);
  2983.                         int indexCR = 1;
  2984.                         if(regola.getReturnCodeMin()!=null && regola.getReturnCodeMin()>0) {
  2985.                             updateStmt.setInt(indexCR++, regola.getReturnCodeMin());
  2986.                         }
  2987.                         if(regola.getReturnCodeMax()!=null && regola.getReturnCodeMax()>0) {
  2988.                             updateStmt.setInt(indexCR++, regola.getReturnCodeMax());
  2989.                         }
  2990.                         updateStmt.setInt(indexCR++, regola.getFault() ? CostantiDB.TRUE : CostantiDB.FALSE);
  2991.                         if(regola.getCacheTimeoutSeconds()!=null && regola.getCacheTimeoutSeconds()>0) {
  2992.                             updateStmt.setInt(indexCR++, regola.getCacheTimeoutSeconds());
  2993.                         }
  2994.                         updateStmt.executeUpdate();
  2995.                         updateStmt.close();
  2996.                         n++;
  2997.                         DriverConfigurazioneDBLib.logDebug("Aggiunta regola di cache");
  2998.                     }
  2999.                 }
  3000.                 
  3001.                 DriverConfigurazioneDBLib.logDebug("Aggiunte " + n + " regole di cache");
  3002.                 
  3003.                 // dumpConfigurazione
  3004.                 
  3005.                 // per backward compatibility elimino una config esistente
  3006.                 dumpConfigOldBackwardCompatibility = DriverConfigurazioneDB_dumpLIB.readDumpConfigurazione(con, null, CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG);
  3007.                 if(dumpConfigOldBackwardCompatibility!=null) {
  3008.                     DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(DELETE, con, dumpConfigOldBackwardCompatibility, null, CostantiDB.OLD_BACKWARD_COMPATIBILITY_DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG);
  3009.                 }
  3010.                 
  3011.                 DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(type, con, dumpConfigPA, null, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  3012.                 DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(type, con, dumpConfigPD, null, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  3013.                 

  3015.                 // delete from msgdiag ds prop
  3016.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3017.                 sqlQueryObject.addDeleteTable(CostantiDB.MSG_DIAGN_DS_PROP);
  3018.                 updateQuery = sqlQueryObject.createSQLDelete();
  3019.                 updateStmt = con.prepareStatement(updateQuery);
  3020.                 updateStmt.executeUpdate();
  3021.                 updateStmt.close();

  3023.                 // delete from msgdiag ds
  3024.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3025.                 sqlQueryObject.addDeleteTable(CostantiDB.MSG_DIAGN_DS);
  3026.                 updateQuery = sqlQueryObject.createSQLDelete();
  3027.                 updateStmt = con.prepareStatement(updateQuery);
  3028.                 updateStmt.executeUpdate();
  3029.                 updateStmt.close();

  3031.                 // insert into msgdiag ds
  3032.                 if(config.getMessaggiDiagnostici()!=null){
  3033.                     for(int k=0; k<config.getMessaggiDiagnostici().sizeOpenspcoopSorgenteDatiList();k++){
  3034.                         OpenspcoopSorgenteDati ds = config.getMessaggiDiagnostici().getOpenspcoopSorgenteDati(k);
  3035.                         
  3036.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  3037.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome", ds.getNome() , InsertAndGeneratedKeyJDBCType.STRING) );
  3038.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome_jndi", ds.getNomeJndi() , InsertAndGeneratedKeyJDBCType.STRING) );
  3039.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo_database", ds.getTipoDatabase() , InsertAndGeneratedKeyJDBCType.STRING) );
  3040.                         
  3041.                         long idMsgDsAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  3042.                                 new CustomKeyGeneratorObject(CostantiDB.MSG_DIAGN_DS, CostantiDB.MSG_DIAGN_DS_COLUMN_ID, 
  3043.                                         CostantiDB.MSG_DIAGN_DS_SEQUENCE, CostantiDB.MSG_DIAGN_DS_TABLE_FOR_ID),
  3044.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  3045.                         if(idMsgDsAppender<=0){
  3046.                             throw new DriverConfigurazioneException("ID (msgdiag ds appender) autoincrementale non ottenuto");
  3047.                         }

  3049.                         for(int l=0; l<ds.sizePropertyList();l++){
  3050.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3051.                             sqlQueryObject.addInsertTable(CostantiDB.MSG_DIAGN_DS_PROP);
  3052.                             sqlQueryObject.addInsertField("id_prop", "?");
  3053.                             sqlQueryObject.addInsertField("nome", "?");
  3054.                             sqlQueryObject.addInsertField("valore", "?");
  3055.                             updateQuery = sqlQueryObject.createSQLInsert();
  3056.                             updateStmt = con.prepareStatement(updateQuery);
  3057.                             updateStmt.setLong(1, idMsgDsAppender);
  3058.                             updateStmt.setString(2, ds.getProperty(l).getNome());
  3059.                             updateStmt.setString(3, ds.getProperty(l).getValore());
  3060.                             updateStmt.executeUpdate();
  3061.                             updateStmt.close();
  3062.                         }

  3064.                     }
  3065.                 }

  3067.                 // delete from tracce ds prop
  3068.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3069.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_DS_PROP);
  3070.                 updateQuery = sqlQueryObject.createSQLDelete();
  3071.                 updateStmt = con.prepareStatement(updateQuery);
  3072.                 updateStmt.executeUpdate();
  3073.                 updateStmt.close();

  3075.                 // delete from tracce ds
  3076.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3077.                 sqlQueryObject.addDeleteTable(CostantiDB.TRACCIAMENTO_DS);
  3078.                 updateQuery = sqlQueryObject.createSQLDelete();
  3079.                 updateStmt = con.prepareStatement(updateQuery);
  3080.                 updateStmt.executeUpdate();
  3081.                 updateStmt.close();

  3083.                 // insert into tracce ds
  3084.                 if(config.getTracciamento()!=null){
  3085.                     for(int k=0; k<config.getTracciamento().sizeOpenspcoopSorgenteDatiList();k++){
  3086.                         OpenspcoopSorgenteDati ds = config.getTracciamento().getOpenspcoopSorgenteDati(k);
  3087.                         
  3088.                         List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  3089.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome", ds.getNome() , InsertAndGeneratedKeyJDBCType.STRING) );
  3090.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome_jndi", ds.getNomeJndi() , InsertAndGeneratedKeyJDBCType.STRING) );
  3091.                         listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("tipo_database", ds.getTipoDatabase() , InsertAndGeneratedKeyJDBCType.STRING) );
  3092.                         
  3093.                         long idTracceDsAppender = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  3094.                                 new CustomKeyGeneratorObject(CostantiDB.TRACCIAMENTO_DS, CostantiDB.TRACCIAMENTO_DS_COLUMN_ID, 
  3095.                                         CostantiDB.TRACCIAMENTO_DS_SEQUENCE, CostantiDB.TRACCIAMENTO_DS_TABLE_FOR_ID),
  3096.                                 listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  3097.                         if(idTracceDsAppender<=0){
  3098.                             throw new DriverConfigurazioneException("ID (tracciamento ds appender) autoincrementale non ottenuto");
  3099.                         }

  3101.                         for(int l=0; l<ds.sizePropertyList();l++){
  3102.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3103.                             sqlQueryObject.addInsertTable(CostantiDB.TRACCIAMENTO_DS_PROP);
  3104.                             sqlQueryObject.addInsertField("id_prop", "?");
  3105.                             sqlQueryObject.addInsertField("nome", "?");
  3106.                             sqlQueryObject.addInsertField("valore", "?");
  3107.                             updateQuery = sqlQueryObject.createSQLInsert();
  3108.                             updateStmt = con.prepareStatement(updateQuery);
  3109.                             updateStmt.setLong(1, idTracceDsAppender);
  3110.                             updateStmt.setString(2, ds.getProperty(l).getNome());
  3111.                             updateStmt.setString(3, ds.getProperty(l).getValore());
  3112.                             updateStmt.executeUpdate();
  3113.                             updateStmt.close();
  3114.                         }

  3116.                     }
  3117.                 }

  3119.                 // Canali
  3120.                 DriverConfigurazioneDB_canaliLIB.CRUDCanaliConfigurazione(type, con, configurazioneCanali);
  3121.                 
  3122.                 
  3123.                 // Handlers
  3124.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, null, null, true, (configHandlers!=null) ? configHandlers.getRequest() : null);
  3125.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, null, null, false, (configHandlers!=null) ? configHandlers.getResponse() : null);
  3126.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneServiceHandlers(type, con, null, null, false, (configHandlers!=null) ? configHandlers.getService() : null);

  3128.                 
  3129.                 // ExtendedInfo
  3130.                 if(extInfoConfigurazioneDriver!=null &&
  3131.                         config.sizeExtendedInfoList()>0){
  3132.                     for(int l=0; l<config.sizeExtendedInfoList();l++){
  3133.                         extInfoConfigurazioneDriver.deleteExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), CRUDType.UPDATE);
  3134.                         extInfoConfigurazioneDriver.createExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), CRUDType.UPDATE);
  3135.                     }
  3136.                 }
  3137.                 

  3139.                 break;

  3141.             case DELETE:
  3142.                 
  3143.                 if(config.sizeExtendedInfoList()>0){
  3144.                     for(int l=0; l<config.sizeExtendedInfoList();l++){
  3145.                         extInfoConfigurazioneDriver.deleteExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), CRUDType.UPDATE);
  3146.                         extInfoConfigurazioneDriver.createExtendedInfo(con, DriverConfigurazioneDBLib.log,  config, config.getExtendedInfo(l), CRUDType.UPDATE);
  3147.                     }
  3148.                 }
  3149.                 
  3150.                 // Canali
  3151.                 DriverConfigurazioneDB_canaliLIB.CRUDCanaliConfigurazione(type, con, configurazioneCanali);
  3152.                 
  3153.                 // Handlers
  3154.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, null, null, true, (configHandlers!=null) ? configHandlers.getRequest() : null);
  3155.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneMessageHandlers(type, con, null, null, false, (configHandlers!=null) ? configHandlers.getResponse() : null);
  3156.                 DriverConfigurazioneDB_handlerLIB.CRUDConfigurazioneServiceHandlers(type, con, null, null, false, (configHandlers!=null) ? configHandlers.getService() : null);
  3157.                 
  3158.                 // Tracciamento

  3160.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneDatabasePA, null, 
  3161.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA,
  3162.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  3163.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneDatabasePD, null, 
  3164.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD,
  3165.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  3166.                 
  3167.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneFiletracePA, null, 
  3168.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA,
  3169.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  3170.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazione(type, con, tracciamentoConfigurazioneFiletracePD, null, 
  3171.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD,
  3172.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  3173.                 
  3174.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoConfigurazioneFiletraceDetailsPA, null, 
  3175.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  3176.                 DriverConfigurazioneDBTracciamentoLIB.crudTracciamentoConfigurazioneFiletrace(type, con, tracciamentoConfigurazioneFiletraceDetailsPD, null, 
  3177.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  3178.                 
  3179.                 // Dump
  3180.                 if(config.getDump()!=null) {
  3181.                     if(config.getDump().getConfigurazionePortaApplicativa()!=null) {
  3182.                         DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(DELETE, con, config.getDump().getConfigurazionePortaApplicativa(), null, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  3183.                     }
  3184.                     if(config.getDump().getConfigurazionePortaDelegata()!=null) {
  3185.                         DriverConfigurazioneDB_dumpLIB.CRUDDumpConfigurazione(DELETE, con, config.getDump().getConfigurazionePortaApplicativa(), null, CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  3186.                     }
  3187.                 }
  3188.                 
  3189.                 // Cache
  3190.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3191.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIGURAZIONE_CACHE_REGOLE);
  3192.                 updateQuery = sqlQueryObject.createSQLDelete();
  3193.                 updateStmt = con.prepareStatement(updateQuery);
  3194.                 updateStmt.executeUpdate();
  3195.                 updateStmt.close();
  3196.                 
  3197.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  3198.                 sqlQueryObject.addDeleteTable(CostantiDB.CONFIGURAZIONE);
  3199.                 updateQuery = sqlQueryObject.createSQLDelete();
  3200.                 updateStmt = con.prepareStatement(updateQuery);
  3201.                 updateStmt.executeUpdate();
  3202.                 updateStmt.close();
  3203.                 break;

  3205.             }

  3207.             if (type == CostantiDB.CREATE)
  3208.                 return idConfigurazione;
  3209.             else
  3210.                 return n;

  3212.         } catch (SQLException se) {
  3213.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConfigurazioneGenerale] SQLException [" + se.getMessage() + "].",se);
  3214.         }catch (Exception se) {
  3215.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConfigurazioneGenerale] Exception [" + se.getMessage() + "].",se);
  3216.         } finally {
  3217.             JDBCUtilities.closeResources(selectRS, selectStmt);
  3218.             JDBCUtilities.closeResources(updateStmt);
  3219.         }
  3220.     }

  3222.     
  3223. }
Created with JaCoCo 0.8.8.202204050719