VaultUpdateConfigUtilities.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.pdd.config.vault.cli;

  22. import java.lang.reflect.InvocationTargetException;
  23. import java.sql.Connection;
  24. import java.sql.DriverManager;
  25. import java.sql.PreparedStatement;
  26. import java.sql.ResultSet;
  27. import java.sql.SQLException;
  28. import java.util.ArrayList;
  29. import java.util.List;

  31. import org.apache.commons.lang.StringUtils;
  32. import org.openspcoop2.core.byok.BYOKUtilities;
  33. import org.openspcoop2.core.byok.BYOKWrappedValue;
  34. import org.openspcoop2.core.commons.CoreException;
  35. import org.openspcoop2.core.commons.DBUtils;
  36. import org.openspcoop2.core.constants.CostantiConnettori;
  37. import org.openspcoop2.core.constants.CostantiDB;
  38. import org.openspcoop2.core.constants.CostantiProprieta;
  39. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  40. import org.openspcoop2.core.id.IDSoggetto;
  41. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  42. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  43. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  44. import org.openspcoop2.pdd.core.byok.DriverBYOK;
  45. import org.openspcoop2.utils.TipiDatabase;
  46. import org.openspcoop2.utils.UtilsException;
  47. import org.openspcoop2.utils.io.Base64Utilities;
  48. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  49. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  50. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  51. import org.openspcoop2.utils.resources.FileSystemUtilities;
  52. import org.openspcoop2.utils.sql.ISQLQueryObject;
  53. import org.openspcoop2.utils.sql.LikeConfig;
  54. import org.openspcoop2.utils.sql.SQLObjectFactory;
  55. import org.openspcoop2.utils.sql.SQLQueryObjectException;

  57. /**
  58. * VaultUpdateConfigUtilities
  59. *
  60. * @author Poli Andrea (apoli@link.it)
  61. * @author $Author$
  62. * @version $Rev$, $Date$
  63. */
  64. public class VaultUpdateConfigUtilities {
  65.     
  66.     private VaultUpdateConfig config;
  67.     
  68.     private DriverBYOK inDriverBYOK = null;
  69.     private DriverBYOK outDriverBYOK = null;
  70.     
  71.     private String tipoDatabase;
  72.     private String driver;
  73.     private String username;
  74.     private String password;
  75.     private String connectionURL;
  76.     
  77.     private static final String LOG_ORIG_SKIPPED = "\t!skyp! wrapped with other policy:";
  78.     private static final String LOG_ORIG_SKIPPED_NO_WRAPPED = "\t!skyp! no wrapped value:";
  79.     private static final String LOG_ORIG_SKIPPED_ALREADY_WRAPPED = "\t!skyp! already wrapped value:";
  80.     private static final String LOG_ORIG_SKIPPED_WITH_POLICY = "\t!skyp! wrapped with policy:";
  81.     private static final String LOG_ORIG = "\torig:";
  82.     private static final String LOG_NEW = "\tnew:";
  83.     private static final String LOG_ROW_UPDATE = "\trow-update:";
  84.     
  85.     private static final String CONDITION_WHERE_ID = "id = ?";
  86.     private static final String CONDITION_JOIN_ID = ".id = ";
  87.     
  88.     private static final String ALIAS_PLAIN_VALUE = "plainValue";
  89.     private static final String ALIAS_ENC_VALUE = "encValue";
  90.     
  91.     public VaultUpdateConfigUtilities(VaultUpdateConfig config) {
  92.         this.config = config;
  93.     }

  95.     public void process() throws CoreException {

  97.         try {
  98.         
  99.             VaultTools.logCoreDebug("Inizializzazione connessione database in corso...");
  100.             
  101.             VaultDatabaseProperties databaseProperties = VaultDatabaseProperties.getInstance();
  102.             this.tipoDatabase = databaseProperties.getTipoDatabase();
  103.             this.driver = databaseProperties.getDriver();
  104.             this.username = databaseProperties.getUsername();
  105.             this.password = databaseProperties.getPassword();
  106.             this.connectionURL = databaseProperties.getConnectionUrl();
  107.     
  108.             VaultTools.logCoreDebug("Inizializzazione connessione database terminata");
  109.             
  110.             
  111.             
  112.             VaultTools.logCoreDebug("Inizializzazione driver ...");
  113.             
  114.             if(this.config.isInSecurityMode()) {
  115.                 this.inDriverBYOK = new DriverBYOK(VaultTools.getLogCore(), this.config.getInId(), this.config.getInId());
  116.             }
  117.             if(this.config.isOutSecurityMode()) {
  118.                 this.outDriverBYOK = new DriverBYOK(VaultTools.getLogCore(), this.config.getOutId(), this.config.getOutId());
  119.             }

  121.             VaultTools.logCoreDebug("Inizializzazione driver terminata");
  122.             
  123.             StringBuilder output = null;
  124.             if(this.config.getReportPath()!=null) {
  125.                 output = new StringBuilder();
  126.             }
  127.             
  128.             processConnettori(output);
  129.             
  130.             processServiziApplicativi(output);
  131.             
  132.             processSecurity(output);
  133.             
  134.             processGenericProperties(output);
  135.             
  136.             processProtocolProperties(output);
  137.             
  138.             processProperties(output); // lasciare in fondo in modo da non gestire nuovamente le proprietà di sicurezza
  139.             
  140.             if(this.config.getReportPath()!=null && output!=null) {
  141.                 FileSystemUtilities.writeFile(this.config.getReportPath(), output.toString().getBytes());
  142.             }
  143.             
  144.         }
  145.         catch(Exception t) {
  146.             VaultTools.logCoreError(t.getMessage(),t);
  147.             throw new CoreException(t.getMessage(),t);
  148.         }

  150.     }
  151.     private void processConnettori(StringBuilder output) throws CoreException {
  152.         VaultTools.logCoreDebug("Conversione connettori ...");
  153.         
  154.         if(output!=null) {
  155.             if(output.length()>0) {
  156.                 output.append("\n\n");
  157.             }
  158.             output.append("=== Connettori ===\n\n");
  159.         }
  160.                 
  161.         updateConnettori("password", "enc_password", output);
  162.         updateConnettori("proxy_password", "enc_proxy_password", output);
  163.         updateConnettori("api_key", null, output);
  164.         
  165.         if(output!=null) {
  166.             output.append("\n\n");
  167.             output.append("=== Connettori Custom ===\n\n");
  168.         }
  169.         
  170.         for (String nomeProprieta : CostantiConnettori.getConfidentials()) {
  171.             updateConnettoriCustom(nomeProprieta, output);
  172.         }
  173.         
  174.         VaultTools.logCoreDebug("Conversione connettori terminata");
  175.     }
  176.     private void processServiziApplicativi(StringBuilder output) throws CoreException {
  177.         VaultTools.logCoreDebug("Conversione applicativi ...");
  178.         
  179.         if(output!=null) {
  180.             if(output.length()>0) {
  181.                 output.append("\n\n");
  182.             }
  183.             output.append("=== Applicativi ===\n\n");
  184.         }
  185.                 
  186.         updateServiziApplicativi("passwordrisp", "enc_passwordrisp", output);
  187.         updateServiziApplicativi("passwordinv", "enc_passwordinv", output);
  188.         
  189.         VaultTools.logCoreDebug("Conversione applicativi terminata");
  190.     }
  191.     private void processSecurity(StringBuilder output) throws CoreException {
  192.         VaultTools.logCoreDebug("Conversione message security ...");
  193.         
  194.         List<String> messageSecurityIds = CostantiProprieta.getMessageSecurityIds();
  195.         
  196.         processSecurityFruizioni(messageSecurityIds, output);
  197.         processSecurityErogazioni(messageSecurityIds, output);
  198.         
  199.         VaultTools.logCoreDebug("Conversione message security terminata");
  200.     }
  201.     private void processSecurityFruizioni(List<String> messageSecurityIds, StringBuilder output) throws CoreException {
  202.         if(output!=null) {
  203.             if(output.length()>0) {
  204.                 output.append("\n\n");
  205.             }
  206.             output.append("=== Message Security (Fruizioni request-flow) ===\n\n");
  207.         }
  208.         
  209.         processSecurity(
  210.                 messageSecurityIds, output,
  211.                 CostantiDB.PORTE_DELEGATE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST, 
  212.                 CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_NOME, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_ENC_VALUE);
  213.                 
  214.         if(output!=null) {
  215.             output.append("\n\n");
  216.             output.append("=== Message Security (Fruizioni response-flow) ===\n\n");
  217.         }
  218.         
  219.         processSecurity(
  220.                 messageSecurityIds, output,
  221.                 CostantiDB.PORTE_DELEGATE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE, 
  222.                 CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_NOME, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_ENC_VALUE);

  224.     }
  225.     private void processSecurityErogazioni(List<String> messageSecurityIds, StringBuilder output) throws CoreException {
  226.         if(output!=null) {
  227.             output.append("\n\n");
  228.             output.append("=== Message Security (Erogazioni request-flow) ===\n\n");
  229.         }
  230.         
  231.         processSecurity(
  232.                 messageSecurityIds, output,
  233.                 CostantiDB.PORTE_APPLICATIVE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST, 
  234.                 CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_NOME, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_ENC_VALUE);
  235.         
  236.         if(output!=null) {
  237.             output.append("\n\n");
  238.             output.append("=== Message Security (Erogazioni response-flow) ===\n\n");
  239.         }
  240.         
  241.         processSecurity(
  242.                 messageSecurityIds, output,
  243.                 CostantiDB.PORTE_APPLICATIVE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE, 
  244.                 CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_NOME, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_ENC_VALUE);
  245.         
  246.     }
  247.     private void processSecurity(List<String> messageSecurityIds, StringBuilder output,
  248.             String tabellaPadre, String tabella, 
  249.             String nomeColonnaNomeProprieta, String nomeColonnaPlain, String nomeColonnaCodificata) throws CoreException {
  250.         if(messageSecurityIds!=null && !messageSecurityIds.isEmpty()) {
  251.             List<String> lnomiProp = new ArrayList<>();  
  252.             for (String id : messageSecurityIds) {
  253.                 List<String> l =  CostantiProprieta.getMessageSecurityProperties(id);
  254.                 for (String nomeProprieta : l) {
  255.                     if(!lnomiProp.contains(nomeProprieta)) {
  256.                         lnomiProp.add(nomeProprieta);
  257.                     }
  258.                 }
  259.             }
  260.             
  261.             for (String nomeProprieta : lnomiProp) {
  262.                 updateMessageSecurity(tabellaPadre, tabella, 
  263.                         nomeColonnaNomeProprieta, nomeColonnaPlain, nomeColonnaCodificata,
  264.                         nomeProprieta, output);
  265.             }
  266.         }
  267.     }
  268.     private void processGenericProperties(StringBuilder output) throws CoreException {
  269.         VaultTools.logCoreDebug("Conversione generic properties ...");
  270.         
  271.         if(output!=null) {
  272.             if(output.length()>0) {
  273.                 output.append("\n\n");
  274.             }
  275.             output.append("=== TokenPolicy Validazione ===\n\n");
  276.         }
  277.         
  278.         for (String nomeProprieta : CostantiProprieta.getTokenValidationProperties()) {
  279.             updateGenericProperties(CostantiProprieta.TOKEN_VALIDATION_ID, nomeProprieta, output);
  280.         }
  281.         
  282.         if(output!=null) {
  283.             output.append("\n\n");
  284.             output.append("=== TokenPolicy Negoziazione ===\n\n");
  285.         }
  286.         
  287.         for (String nomeProprieta : CostantiProprieta.getTokenRetrieveProperties()) {
  288.             updateGenericProperties(CostantiProprieta.TOKEN_NEGOZIAZIONE_ID, nomeProprieta, output);
  289.         }
  290.         
  291.         if(output!=null) {
  292.             output.append("\n\n");
  293.             output.append("=== Attribute Authority ===\n\n");
  294.         }
  295.         
  296.         for (String nomeProprieta : CostantiProprieta.getAttributeAuthorityProperties()) {
  297.             updateGenericProperties(CostantiProprieta.ATTRIBUTE_AUTHORITY_ID, nomeProprieta, output);
  298.         }
  299.         
  300.         VaultTools.logCoreDebug("Conversione generic properties terminata");
  301.     }
  302.     private void processProtocolProperties(StringBuilder output) throws CoreException {
  303.         VaultTools.logCoreDebug("Conversione protocol properties ...");
  304.         
  305.         if(output!=null) {
  306.             if(output.length()>0) {
  307.                 output.append("\n\n");
  308.             }
  309.             output.append("=== ProtocolProperties ===\n\n");
  310.         }
  311.         
  312.         // DBProtocolPropertiesUtils.getProtocolPropertiesConfidentials()
  313.         // Non uso questo metodo poichè viene inizializzato dalla ModI Factory e nel vault non viene usato alcun protocollo
  314.         
  315.         updateProtocolProperties(CostantiDB.MODIPA_KEYSTORE_PASSWORD, false, output);
  316.         updateProtocolProperties(CostantiDB.MODIPA_KEY_PASSWORD, false, output);
  317.         updateProtocolProperties(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CERTIFICATI_TRUSTSTORE_PASSWORD, false, output);
  318.         updateProtocolProperties(CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SSL_TRUSTSTORE_PASSWORD, false, output);
  319.         
  320.         updateProtocolProperties(CostantiDB.MODIPA_KEYSTORE_ARCHIVE, true, output);
  321.         
  322.         VaultTools.logCoreDebug("Conversione protocol properties terminata");
  323.     }
  324.     private void processProperties(StringBuilder output) throws CoreException {
  325.         VaultTools.logCoreDebug("Conversione properties ...");
  326.         
  327.         if(output!=null) {
  328.             if(output.length()>0) {
  329.                 output.append("\n\n");
  330.             }
  331.             output.append("=== Soggetti properties ===\n\n");
  332.         }
  333.                 
  334.         updateProperties(CostantiDB.SOGGETTI_PROPS, CostantiDB.SOGGETTI_PROPS_COLUMN_NAME, CostantiDB.SOGGETTI_PROPS_COLUMN_VALUE, CostantiDB.SOGGETTI_PROPS_COLUMN_ENC_VALUE, output,
  335.                 false, false);
  336.         
  337.         if(output!=null) {
  338.             output.append("\n\n");
  339.             output.append("=== Applicativi properties ===\n\n");
  340.         }
  341.         
  342.         updateProperties(CostantiDB.SERVIZI_APPLICATIVI_PROPS, CostantiDB.SERVIZI_APPLICATIVI_PROPS_COLUMN_NOME, CostantiDB.SERVIZI_APPLICATIVI_PROPS_COLUMN_VALUE, CostantiDB.SERVIZI_APPLICATIVI_PROPS_COLUMN_ENC_VALUE, output,
  343.                 false, false);
  344.         
  345.         if(output!=null) {
  346.             output.append("\n\n");
  347.             output.append("=== Configurazione properties ===\n\n");
  348.         }
  349.         
  350.         updateProperties(CostantiDB.SYSTEM_PROPERTIES_PDD, CostantiDB.SYSTEM_PROPERTIES_PDD_COLUMN_NOME, CostantiDB.SYSTEM_PROPERTIES_PDD_COLUMN_VALUE, CostantiDB.SYSTEM_PROPERTIES_PDD_COLUMN_ENC_VALUE, output,
  351.                 false, false);
  352.         
  353.         
  354.         processErogazioniProperties(output);
  355.         
  356.         processFruizioniProperties(output);

  358.         VaultTools.logCoreDebug("Conversione properties terminata");
  359.     }
  360.     private void processErogazioniProperties(StringBuilder output) throws CoreException {
  361.         if(output!=null) {
  362.             output.append("\n\n");
  363.             output.append("=== Erogazioni message security request properties ===\n\n");
  364.         }
  365.         
  366.         updateProperties(CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_NOME, 
  367.                 CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST_COLUMN_ENC_VALUE, output,
  368.                 true, false);
  369.         
  370.         if(output!=null) {
  371.             output.append("\n\n");
  372.             output.append("=== Erogazioni message security response properties ===\n\n");
  373.         }
  374.         
  375.         updateProperties(CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_NOME, 
  376.                 CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE_COLUMN_ENC_VALUE, output,
  377.                 false, true);
  378.         
  379.         if(output!=null) {
  380.             output.append("\n\n");
  381.             output.append("=== Erogazioni autenticazione properties ===\n\n");
  382.         }
  383.         
  384.         updateProperties(CostantiDB.PORTE_APPLICATIVE_AUTENTICAZIONE_PROP, CostantiDB.PORTE_APPLICATIVE_AUTENTICAZIONE_PROP_COLUMN_NOME, 
  385.                 CostantiDB.PORTE_APPLICATIVE_AUTENTICAZIONE_PROP_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_AUTENTICAZIONE_PROP_COLUMN_ENC_VALUE, output,
  386.                 false, false);
  387.         
  388.         if(output!=null) {
  389.             output.append("\n\n");
  390.             output.append("=== Erogazioni autorizzazione properties ===\n\n");
  391.         }
  392.         
  393.         updateProperties(CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_PROP, CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_PROP_COLUMN_NOME, 
  394.                 CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_PROP_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_PROP_COLUMN_ENC_VALUE, output,
  395.                 false, false);
  396.         
  397.         if(output!=null) {
  398.             output.append("\n\n");
  399.             output.append("=== Erogazioni autorizzazione contenuti properties ===\n\n");
  400.         }
  401.         
  402.         updateProperties(CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_CONTENUTI_PROP, CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_CONTENUTI_PROP_COLUMN_NOME, 
  403.                 CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_CONTENUTI_PROP_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_CONTENUTI_PROP_COLUMN_ENC_VALUE, output,
  404.                 false, false);
  405.         
  406.         if(output!=null) {
  407.             output.append("\n\n");
  408.             output.append("=== Erogazioni properties ===\n\n");
  409.         }
  410.         
  411.         updateProperties(CostantiDB.PORTE_APPLICATIVE_PROP, CostantiDB.PORTE_APPLICATIVE_PROP_COLUMN_NOME, 
  412.                 CostantiDB.PORTE_APPLICATIVE_PROP_COLUMN_VALORE, CostantiDB.PORTE_APPLICATIVE_PROP_COLUMN_ENC_VALUE, output,
  413.                 false, false);
  414.     }
  415.     private void processFruizioniProperties(StringBuilder output) throws CoreException {
  416.         if(output!=null) {
  417.             output.append("\n\n");
  418.             output.append("=== Fruizioni message security request properties ===\n\n");
  419.         }
  420.         
  421.         updateProperties(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_NOME, 
  422.                 CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST_COLUMN_ENC_VALUE, output,
  423.                 true, false);
  424.         
  425.         if(output!=null) {
  426.             output.append("\n\n");
  427.             output.append("=== Fruizioni message security response properties ===\n\n");
  428.         }
  429.         
  430.         updateProperties(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_NOME, 
  431.                 CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE_COLUMN_ENC_VALUE, output,
  432.                 false, true);
  433.         
  434.         if(output!=null) {
  435.             output.append("\n\n");
  436.             output.append("=== Fruizioni autenticazione properties ===\n\n");
  437.         }
  438.         
  439.         updateProperties(CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP, CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP_COLUMN_NOME, 
  440.                 CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP_COLUMN_ENC_VALUE, output,
  441.                 false, false);
  442.         
  443.         if(output!=null) {
  444.             output.append("\n\n");
  445.             output.append("=== Fruizioni autorizzazione properties ===\n\n");
  446.         }
  447.         
  448.         updateProperties(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP, CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP_COLUMN_NOME, 
  449.                 CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP_COLUMN_ENC_VALUE, output,
  450.                 false, false);
  451.         
  452.         if(output!=null) {
  453.             output.append("\n\n");
  454.             output.append("=== Fruizioni autorizzazione contenuti properties ===\n\n");
  455.         }
  456.         
  457.         updateProperties(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP, CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP_COLUMN_NOME, 
  458.                 CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP_COLUMN_ENC_VALUE, output,
  459.                 false, false);
  460.         
  461.         if(output!=null) {
  462.             output.append("\n\n");
  463.             output.append("=== Fruizioni properties ===\n\n");
  464.         }
  465.         
  466.         updateProperties(CostantiDB.PORTE_DELEGATE_PROP, CostantiDB.PORTE_DELEGATE_PROP_COLUMN_NOME, 
  467.                 CostantiDB.PORTE_DELEGATE_PROP_COLUMN_VALORE, CostantiDB.PORTE_DELEGATE_PROP_COLUMN_ENC_VALUE, output,
  468.                 false, false);
  469.     }
  470.     
  471.     
  472.     
  473.     
  474.     // UTILS
  475.     
  476.     private Connection getConnection() throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, SQLException {
  477.         Connection connectionSQL = null;
  478.         org.openspcoop2.utils.resources.Loader.getInstance().newInstance(this.driver);
  479.         if(this.username!=null && this.password!=null){
  480.             connectionSQL = DriverManager.getConnection(this.connectionURL,this.username,this.password);
  481.         }else{
  482.             connectionSQL = DriverManager.getConnection(this.connectionURL);
  483.         }
  484.         return connectionSQL;
  485.     }
  486.     private void closeConnection(Connection connectionSQL) {
  487.         if(connectionSQL!=null) {
  488.             try {
  489.                 connectionSQL.close();
  490.             }catch(Exception e) {
  491.                 // ignore
  492.             }
  493.         }
  494.     }
  495.     
  496.     private void skip(StringBuilder output, String prefix, String value, boolean wrapped) {
  497.         if(output!=null) {
  498.             output.append(prefix).append("\n");
  499.             output.append(wrapped ? LOG_ORIG_SKIPPED : LOG_ORIG_SKIPPED_NO_WRAPPED).append(value).append("\n");
  500.         }
  501.     }
  502.     private void skipWithPolicy(StringBuilder output, String prefix, String value) {
  503.         if(output!=null) {
  504.             output.append(prefix).append("\n");
  505.             output.append(LOG_ORIG_SKIPPED_WITH_POLICY).append(value).append("\n");
  506.         }
  507.     }
  508.     private void skipAlreadyWrapped(StringBuilder output, String prefix, String value) {
  509.         if(output!=null) {
  510.             output.append(prefix).append("\n");
  511.             output.append(LOG_ORIG_SKIPPED_ALREADY_WRAPPED).append(value).append("\n");
  512.         }
  513.     }
  514.     
  515.     private void updateValue(Connection connectionSQL, ResultSet rs, String nomeColonna, 
  516.             String prefix, StringBuilder output,
  517.             VaultUpdateConfigValue c) throws UtilsException, SQLException, SQLQueryObjectException {
  518.         
  519.         String plainStringValue = rs.getString(nomeColonna);
  520.         String updatedValue = null;
  521.         if(this.inDriverBYOK!=null && 
  522.                 plainStringValue!=null && StringUtils.isNotEmpty(plainStringValue)) {
  523.             if(BYOKUtilities.isWrappedValue(plainStringValue)) {
  524.                 if(this.inDriverBYOK.isWrappedWithInternalPolicy(plainStringValue)) {
  525.                     updatedValue = this.inDriverBYOK.unwrapAsString(plainStringValue);
  526.                 }
  527.                 else {
  528.                     // trovato un valore cifrato con una security policy differente ?
  529.                     // non effettua il wrap anche se richiesto
  530.                     skip(output, prefix, plainStringValue, true);
  531.                     return;
  532.                 }
  533.             }
  534.             else {
  535.                 // trovato un valore non cifrato con una security policy
  536.                 // non effettua il wrap anche se richiesto
  537.                 skip(output, prefix, plainStringValue, false);
  538.                 return;
  539.             }
  540.         }
  541.         else {
  542.             if(plainStringValue!=null && StringUtils.isNotEmpty(plainStringValue) && BYOKUtilities.isWrappedValue(plainStringValue)) {
  543.                 // trovato un valore cifrato con una security policy, non devo quindi considerarlo
  544.                 skipWithPolicy(output, prefix, plainStringValue);
  545.                 return;
  546.             }
  547.         }
  548.         
  549.         if(this.outDriverBYOK!=null || updatedValue!=null) {
  550.             updateValue(connectionSQL, output,
  551.                     plainStringValue, updatedValue, 
  552.                     c, prefix);
  553.         }
  554.         
  555.     }
  556.     private void updateValue(Connection connectionSQL, StringBuilder output,
  557.             String plainStringValue, String updatedValue, 
  558.             VaultUpdateConfigValue c, String prefix) throws SQLQueryObjectException, SQLException, UtilsException {
  559.         
  560.         if(this.outDriverBYOK!=null) {
  561.             String v = updatedValue!=null ? updatedValue : plainStringValue;
  562.             if(this.outDriverBYOK.isWrappedWithInternalPolicy(v)) {
  563.                 // Il valore di destinazione risulta già cifrato con la policy richiesta
  564.                 skipAlreadyWrapped(output, prefix, v);
  565.                 return;
  566.             }
  567.         }
  568.         
  569.         if(output!=null) {
  570.             output.append(prefix).append("\n");
  571.             output.append(LOG_ORIG).append(plainStringValue).append("\n");
  572.         }
  573.         
  574.         updateValue(connectionSQL, output,
  575.                 plainStringValue, updatedValue, 
  576.                 c);
  577.         
  578.         if(output!=null) {
  579.             output.append("\n\n");
  580.         }
  581.     }
  582.     private void updateValue(Connection connectionSQL, StringBuilder output,
  583.             String plainStringValue, String updatedValue, 
  584.             VaultUpdateConfigValue updateConfig) throws SQLQueryObjectException, SQLException, UtilsException {
  585.         
  586.         PreparedStatement stmUpdate = null;
  587.         try {
  588.             BYOKWrappedValue wrappedValue =null;
  589.             if(this.outDriverBYOK!=null) {
  590.                 wrappedValue = this.outDriverBYOK.wrap(updatedValue!=null ? updatedValue : plainStringValue);
  591.             }   
  592.             
  593.             ISQLQueryObject sqlQueryObjectUpdate = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  594.             sqlQueryObjectUpdate.addUpdateTable(updateConfig.tabella);
  595.             sqlQueryObjectUpdate.addUpdateField(updateConfig.nomeColonna, "?");
  596.             sqlQueryObjectUpdate.addWhereCondition(CONDITION_WHERE_ID);
  597.             sqlQueryObjectUpdate.setANDLogicOperator(true);
  598.             String sqlUpdate = sqlQueryObjectUpdate.createSQLUpdate();
  599.             stmUpdate = connectionSQL.prepareStatement(sqlUpdate);
  600.             int index = 1;
  601.             if(wrappedValue!=null) {
  602.                 stmUpdate.setString(index++, wrappedValue.getWrappedValue());
  603.                 if(output!=null) {
  604.                     output.append(LOG_NEW).append(wrappedValue.getWrappedValue()).append("\n");
  605.                 }
  606.             }
  607.             else {
  608.                 stmUpdate.setString(index++, updatedValue);
  609.                 if(output!=null) {
  610.                     output.append(LOG_NEW).append(updatedValue).append("\n");
  611.                 }
  612.             }
  613.             stmUpdate.setLong(index++, updateConfig.id);
  614.             int row = stmUpdate.executeUpdate();
  615.             if(output!=null) {
  616.                 output.append(LOG_ROW_UPDATE).append(row).append("\n");
  617.             }
  618.             stmUpdate.close();
  619.         } finally {
  620.             JDBCUtilities.closeResources(stmUpdate);
  621.         }
  622.     }
  623.     
  624.     
  625.     private void updatePlainEncValue(Connection connectionSQL, ResultSet rs, String nomeColonnaPlain, String nomeColonnaCodificata, 
  626.             String prefix, StringBuilder output,
  627.             VaultUpdateConfigPlainEnc c) throws UtilsException, SQLException, SQLQueryObjectException {
  628.         
  629.         String plainStringValue = rs.getString(nomeColonnaPlain);
  630.         String encStringValue = rs.getString(nomeColonnaCodificata);
  631.         String updatedValue = null;
  632.         if(this.inDriverBYOK!=null) {
  633.             if(encStringValue!=null && StringUtils.isNotEmpty(encStringValue)) {
  634.                 if(this.inDriverBYOK.isWrappedWithInternalPolicy(encStringValue)) {
  635.                     updatedValue = this.inDriverBYOK.unwrapAsString(encStringValue);
  636.                 }
  637.                 else {
  638.                     // trovato un valore cifrato con una security policy differente ?
  639.                     // non effettua il wrap anche se richiesto
  640.                     skip(output, prefix, encStringValue, true);
  641.                     return;
  642.                 }
  643.             }
  644.             else {
  645.                 // trovato un valore non cifrato con una security policy
  646.                 // non effettua il wrap anche se richiesto
  647.                 skip(output, prefix, plainStringValue, false);
  648.                 return;
  649.             }
  650.         }
  651.         else {
  652.             if(encStringValue!=null && StringUtils.isNotEmpty(encStringValue)) {
  653.                 // trovato un valore cifrato con una security policy, non devo quindi considerarlo
  654.                 skipWithPolicy(output, prefix, encStringValue);
  655.                 return;
  656.             }
  657.         }
  658.         
  659.         if(this.outDriverBYOK!=null || updatedValue!=null) {
  660.             updatePlainEncValue(connectionSQL, output,
  661.                     plainStringValue, encStringValue, updatedValue, 
  662.                     c, prefix);
  663.         }
  664.         
  665.     }
  666.     private void updatePlainEncValue(Connection connectionSQL, StringBuilder output,
  667.             String plainStringValue, String encStringValue, String updatedValue, 
  668.             VaultUpdateConfigPlainEnc c, String prefix) throws SQLQueryObjectException, SQLException, UtilsException {
  669.         
  670.         if(this.outDriverBYOK!=null) {
  671.             String v = updatedValue!=null ? updatedValue : plainStringValue;
  672.             if(this.outDriverBYOK.isWrappedWithInternalPolicy(v)) {
  673.                 // Il valore di destinazione risulta già cifrato con la policy richiesta
  674.                 skipAlreadyWrapped(output, prefix, v);
  675.                 return;
  676.             }
  677.         }
  678.         
  679.         if(output!=null) {
  680.             output.append(prefix).append("\n");
  681.             output.append(LOG_ORIG).append(encStringValue!=null && StringUtils.isNotEmpty(encStringValue) ? encStringValue : plainStringValue).append("\n");
  682.         }
  683.         
  684.         updatePlainEncValue(connectionSQL, output,
  685.                 plainStringValue, updatedValue, 
  686.                 c);
  687.         
  688.         if(output!=null) {
  689.             output.append("\n\n");
  690.         }
  691.     }
  692.     private void updatePlainEncValue(Connection connectionSQL, StringBuilder output,
  693.             String plainStringValue, String updatedValue, 
  694.             VaultUpdateConfigPlainEnc plainEncConfig) throws SQLQueryObjectException, SQLException, UtilsException {
  695.         
  696.         PreparedStatement stmUpdate = null;
  697.         try {
  698.             BYOKWrappedValue wrappedValue =null;
  699.             if(this.outDriverBYOK!=null) {
  700.                 wrappedValue = this.outDriverBYOK.wrap(updatedValue!=null ? updatedValue : plainStringValue);
  701.             }   
  702.             
  703.             ISQLQueryObject sqlQueryObjectUpdate = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  704.             sqlQueryObjectUpdate.addUpdateTable(plainEncConfig.tabella);
  705.             sqlQueryObjectUpdate.addUpdateField(plainEncConfig.nomeColonnaPlain, "?");
  706.             sqlQueryObjectUpdate.addUpdateField(plainEncConfig.nomeColonnaCodificata, "?");
  707.             sqlQueryObjectUpdate.addWhereCondition(CONDITION_WHERE_ID);
  708.             sqlQueryObjectUpdate.setANDLogicOperator(true);
  709.             String sqlUpdate = sqlQueryObjectUpdate.createSQLUpdate();
  710.             stmUpdate = connectionSQL.prepareStatement(sqlUpdate);
  711.             int index = 1;
  712.             if(wrappedValue!=null) {
  713.                 stmUpdate.setString(index++, wrappedValue.getWrappedPlainValue());
  714.                 stmUpdate.setString(index++, wrappedValue.getWrappedValue());
  715.                 if(output!=null) {
  716.                     output.append(LOG_NEW).append(wrappedValue.getWrappedValue()).append("\n");
  717.                 }
  718.             }
  719.             else {
  720.                 stmUpdate.setString(index++, updatedValue);
  721.                 stmUpdate.setString(index++, null);
  722.                 if(output!=null) {
  723.                     output.append(LOG_NEW).append(updatedValue).append("\n");
  724.                 }
  725.             }
  726.             stmUpdate.setLong(index++, plainEncConfig.id);
  727.             int row = stmUpdate.executeUpdate();
  728.             if(output!=null) {
  729.                 output.append(LOG_ROW_UPDATE).append(row).append("\n");
  730.             }
  731.             stmUpdate.close();
  732.         } finally {
  733.             JDBCUtilities.closeResources(stmUpdate);
  734.         }
  735.     }

  737.     
  738.     private void updateBinaryProtocolProperty(IJDBCAdapter jdbcAdapter, Connection connectionSQL, ResultSet rs, String nomeColonna, 
  739.             String prefix, StringBuilder output,
  740.             VaultUpdateConfigValue c) throws UtilsException, SQLException, SQLQueryObjectException {

  742.         byte[]binaryValue = jdbcAdapter.getBinaryData(rs,nomeColonna);
  743.         byte[]updateValue = null;
  744.         if(this.inDriverBYOK!=null &&
  745.             binaryValue!=null && binaryValue.length>0) {
  746.             if(BYOKUtilities.isWrappedValue(binaryValue)) {
  747.                 if(this.inDriverBYOK.isWrappedWithInternalPolicy(binaryValue)) {
  748.                     updateValue = this.inDriverBYOK.unwrap(binaryValue);
  749.                 }
  750.                 else {
  751.                     // trovato un valore cifrato con una security policy differente ?
  752.                     // non effettua il wrap anche se richiesto
  753.                     skip(output, prefix, BYOKUtilities.extractPrefixWrappedValue(binaryValue), true);
  754.                     return;
  755.                 }
  756.             }
  757.             else {
  758.                 // trovato un valore non cifrato con una security policy
  759.                 // non effettua il wrap anche se richiesto
  760.                 skip(output, prefix, "--binary-value--", false);
  761.                 return;
  762.             }
  763.         }
  764.         else {
  765.             if(binaryValue!=null && binaryValue.length>0 && BYOKUtilities.isWrappedValue(binaryValue)) {
  766.                 // trovato un valore cifrato con una security policy, non devo quindi considerarlo
  767.                 skipWithPolicy(output, prefix, BYOKUtilities.extractPrefixWrappedValue(binaryValue));
  768.                 return;
  769.             }
  770.         }
  771.         
  772.         if(this.outDriverBYOK!=null || updateValue!=null) {
  773.             updateBinaryValue(jdbcAdapter, connectionSQL, output, 
  774.                     binaryValue, updateValue, 
  775.                     c, prefix);         
  776.         }
  777.         
  778.     }
  779.     private void updateBinaryValue(IJDBCAdapter jdbcAdapter, Connection connectionSQL, StringBuilder output, 
  780.             byte[]binaryValue, byte[]updateValue, 
  781.             VaultUpdateConfigValue c, String prefix) throws UtilsException, SQLQueryObjectException, SQLException {
  782.         
  783.         if(this.outDriverBYOK!=null) {
  784.             byte[] v = updateValue!=null ? updateValue : binaryValue;
  785.             if(this.outDriverBYOK.isWrappedWithInternalPolicy(v)) {
  786.                 // Il valore di destinazione risulta già cifrato con la policy richiesta
  787.                 skipAlreadyWrapped(output, prefix, BYOKUtilities.extractPrefixWrappedValue(v));
  788.                 return;
  789.             }
  790.         }
  791.         
  792.         if(output!=null) {
  793.             output.append(prefix).append("\n");
  794.             String base64 = Base64Utilities.encodeAsString(binaryValue);
  795.             output.append(LOG_ORIG).append(base64).append("\n");
  796.         }
  797.         
  798.         updateBinaryValue(jdbcAdapter, connectionSQL, output, 
  799.                 binaryValue, updateValue, 
  800.                 c);
  801.         
  802.         if(output!=null) {
  803.             output.append("\n\n");
  804.         }
  805.     }
  806.     private void updateBinaryValue(IJDBCAdapter jdbcAdapter, Connection connectionSQL, StringBuilder output, 
  807.             byte[]binaryValue, byte[]updateValue, 
  808.             VaultUpdateConfigValue binaryConfig) throws UtilsException, SQLQueryObjectException, SQLException {
  809.         PreparedStatement stmUpdate = null;
  810.         try {
  811.             BYOKWrappedValue wrappedValue =null;
  812.             if(this.outDriverBYOK!=null) {
  813.                 wrappedValue = this.outDriverBYOK.wrap(updateValue!=null ? updateValue : binaryValue);
  814.             }
  815.             
  816.             ISQLQueryObject sqlQueryObjectUpdate = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  817.             sqlQueryObjectUpdate.addUpdateTable(binaryConfig.tabella);
  818.             sqlQueryObjectUpdate.addUpdateField(binaryConfig.nomeColonna, "?");
  819.             sqlQueryObjectUpdate.addWhereCondition(CONDITION_WHERE_ID);
  820.             sqlQueryObjectUpdate.setANDLogicOperator(true);
  821.             String sqlUpdate = sqlQueryObjectUpdate.createSQLUpdate();
  822.             stmUpdate = connectionSQL.prepareStatement(sqlUpdate);
  823.             int index = 1;
  824.             if(wrappedValue!=null) {
  825.                 jdbcAdapter.setBinaryData(stmUpdate,index++,wrappedValue.getWrappedValue().getBytes());
  826.                 if(output!=null) {
  827.                     String base64 = Base64Utilities.encodeAsString(wrappedValue.getWrappedValue().getBytes());
  828.                     output.append(LOG_NEW).append(base64).append("\n");
  829.                 }
  830.             }
  831.             else {
  832.                 jdbcAdapter.setBinaryData(stmUpdate,index++,updateValue);
  833.                 if(output!=null) {
  834.                     String base64 = Base64Utilities.encodeAsString(updateValue);
  835.                     output.append(LOG_NEW).append(base64).append("\n");
  836.                 }
  837.             }
  838.             stmUpdate.setLong(index++, binaryConfig.id);
  839.             int row = stmUpdate.executeUpdate();
  840.             if(output!=null) {
  841.                 output.append(LOG_ROW_UPDATE).append(row).append("\n");
  842.             }
  843.             stmUpdate.close();
  844.         } finally {
  845.             JDBCUtilities.closeResources(stmUpdate);
  846.         }
  847.     }
  848.     
  849.     
  850.     
  851.     
  852.     
  853.     // CONNETTORI
  854.     
  855.     private void updateConnettori(String nomeColonnaPlain, String nomeColonnaCodificata, StringBuilder output) throws CoreException {
  856.         PreparedStatement stmRead = null;
  857.         ResultSet rs=null;
  858.         
  859.         Connection connectionSQL = null;
  860.         try {
  861.             connectionSQL = getConnection();
  862.             
  863.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  864.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  865.             sqlQueryObject.addWhereIsNotNullCondition(nomeColonnaPlain);
  866.             if(!TipiDatabase.ORACLE.equals(this.tipoDatabase)) {
  867.                 // In oracle le stringhe vuote equivalgono a null
  868.                 sqlQueryObject.addWhereIsNotEmptyCondition(nomeColonnaPlain);
  869.             }
  870.             sqlQueryObject.setANDLogicOperator(true);
  871.             sqlQueryObject.addOrderBy(CostantiDB.CONNETTORI_COLUMN_NOME);
  872.             String sqlQuery = sqlQueryObject.createSQLQuery();
  873.             stmRead = connectionSQL.prepareStatement(sqlQuery);
  874.             rs = stmRead.executeQuery();
  875.             
  876.             while(rs.next()){
  877.                 
  878.                 long id = rs.getLong("id");
  879.                 String nomeConnettore = rs.getString(CostantiDB.CONNETTORI_COLUMN_NOME);
  880.                 String endpointtype = rs.getString(CostantiDB.CONNETTORI_COLUMN_ENDPOINT_TYPE);
  881.                 String prefix = "["+nomeConnettore+"][tipoConnettore:"+endpointtype+"][idConnettore:"+id+"] '"+nomeColonnaPlain+"' ";
  882.                 
  883.                 if(nomeColonnaCodificata!=null) {
  884.                     VaultUpdateConfigPlainEnc c = new VaultUpdateConfigPlainEnc();
  885.                     c.tabella = CostantiDB.CONNETTORI;
  886.                     c.nomeColonnaPlain = nomeColonnaPlain;
  887.                     c.nomeColonnaCodificata = nomeColonnaCodificata;
  888.                     c.id = id;
  889.                     updatePlainEncValue(connectionSQL, rs, nomeColonnaPlain, nomeColonnaCodificata,
  890.                             prefix, output,
  891.                             c);
  892.                 }
  893.                 else {
  894.                     VaultUpdateConfigValue c = new VaultUpdateConfigValue();
  895.                     c.tabella = CostantiDB.CONNETTORI;
  896.                     c.nomeColonna = nomeColonnaPlain;
  897.                     c.id = id;
  898.                     updateValue(connectionSQL, rs, nomeColonnaPlain, 
  899.                             prefix, output,
  900.                             c);
  901.                 }
  902.             
  903.             }
  904.             
  905.         } catch (Exception se) {
  906.             throw new CoreException("[updateConnettori] failed: " + se.getMessage(),se);
  907.         } finally {
  908.             JDBCUtilities.closeResources(rs, stmRead);
  909.             closeConnection(connectionSQL);
  910.         }
  911.     }
  912.     
  913.     private void updateConnettoriCustom(String nomeProprieta, StringBuilder output) throws CoreException {
  914.         PreparedStatement stmRead = null;
  915.         ResultSet rs=null;
  916.         
  917.         Connection connectionSQL = null;
  918.         try {
  919.             connectionSQL = getConnection();
  920.             
  921.             String aliasIdConnettore = "idCon";
  922.             String aliasNomeConnettore = "nomeCon";
  923.             String aliasTipoConnettore = "tipoCon";
  924.             String aliasIdConnettoreCustsom = "idConCustom";
  925.             String aliasNomeConnettoreCustsom = "nomeConCustom";
  926.             String aliasPlanValueConnettoreCustsom = "plainConCustom";
  927.             String aliasEncValueConnettoreCustsom = "encConCustom";
  928.             
  929.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  930.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  931.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI_CUSTOM);
  932.             sqlQueryObject.addSelectAliasField(CostantiDB.CONNETTORI, CostantiDB.CONNETTORI_COLUMN_NOME, aliasNomeConnettore);
  933.             sqlQueryObject.addSelectAliasField(CostantiDB.CONNETTORI, CostantiDB.CONNETTORI_COLUMN_ENDPOINT_TYPE, aliasTipoConnettore);
  934.             sqlQueryObject.addSelectAliasField(CostantiDB.CONNETTORI, "id", aliasIdConnettore);
  935.             sqlQueryObject.addSelectAliasField(CostantiDB.CONNETTORI_CUSTOM, "id", aliasIdConnettoreCustsom);
  936.             sqlQueryObject.addSelectAliasField(CostantiDB.CONNETTORI_CUSTOM, CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME, aliasNomeConnettoreCustsom);
  937.             sqlQueryObject.addSelectAliasField(CostantiDB.CONNETTORI_CUSTOM, CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE, aliasPlanValueConnettoreCustsom);
  938.             sqlQueryObject.addSelectAliasField(CostantiDB.CONNETTORI_CUSTOM, CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE, aliasEncValueConnettoreCustsom);
  939.             sqlQueryObject.addWhereCondition(CostantiDB.CONNETTORI+CONDITION_JOIN_ID+CostantiDB.CONNETTORI_CUSTOM+"."+CostantiDB.CONNETTORI_CUSTOM_COLUMN_ID_CONNETTORE);
  940.             sqlQueryObject.addWhereCondition(CostantiDB.CONNETTORI_CUSTOM+"."+CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME+"=?");
  941.             sqlQueryObject.addWhereIsNotNullCondition(CostantiDB.CONNETTORI_CUSTOM+"."+CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE);
  942.             if(!TipiDatabase.ORACLE.equals(this.tipoDatabase)) {
  943.                 // In oracle le stringhe vuote equivalgono a null
  944.                 sqlQueryObject.addWhereIsNotEmptyCondition(CostantiDB.CONNETTORI_CUSTOM+"."+CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE);
  945.             }
  946.             sqlQueryObject.addWhereCondition(true, true, CostantiDB.CONNETTORI_CUSTOM+"."+CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE+"='"+CostantiDB.MODIPA_VALUE_UNDEFINED+"'"); // vale anche per security properties
  947.             sqlQueryObject.setANDLogicOperator(true);
  948.             sqlQueryObject.addOrderBy(CostantiDB.CONNETTORI_COLUMN_NOME);
  949.             sqlQueryObject.setSelectDistinct(true);
  950.             String sqlQuery = sqlQueryObject.createSQLQuery();
  951.             stmRead = connectionSQL.prepareStatement(sqlQuery);
  952.             stmRead.setString(1, nomeProprieta);
  953.             rs = stmRead.executeQuery();
  954.             
  955.             while(rs.next()){
  956.                 
  957.                 long idCustom = rs.getLong(aliasIdConnettoreCustsom);
  958.                 long idConnettore = rs.getLong(aliasIdConnettore);
  959.                 String nomeConnettore = rs.getString(aliasNomeConnettore);
  960.                 String endpointtype = rs.getString(aliasTipoConnettore);
  961.                 String prefix = "["+nomeConnettore+"][tipoConnettore:"+endpointtype+"][idConnettore:"+idConnettore+"][idCustomProp:"+idCustom+"] '"+nomeProprieta+"' ";
  962.                 
  963.                 VaultUpdateConfigPlainEnc c = new VaultUpdateConfigPlainEnc();
  964.                 c.tabella = CostantiDB.CONNETTORI_CUSTOM;
  965.                 c.nomeColonnaPlain = CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE;
  966.                 c.nomeColonnaCodificata = CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE;
  967.                 c.id = idCustom;
  968.                 updatePlainEncValue(connectionSQL, rs, aliasPlanValueConnettoreCustsom, aliasEncValueConnettoreCustsom,
  969.                         prefix, output,
  970.                         c);
  971.             
  972.             }
  973.             
  974.         } catch (Exception se) {
  975.             throw new CoreException("[updateConnettoriCustom] failed: " + se.getMessage(),se);
  976.         } finally {
  977.             JDBCUtilities.closeResources(rs, stmRead);
  978.             closeConnection(connectionSQL);
  979.         }
  980.     }

  982.     
  983.     
  984.     
  985.     
  986.     
  987.     
  988.     
  989.     
  990.     // SERVIZI APPLICATIVI
  991.     
  992.     private void updateServiziApplicativi(String nomeColonnaPlain, String nomeColonnaCodificata, StringBuilder output) throws CoreException {
  993.         PreparedStatement stmRead = null;
  994.         ResultSet rs=null;
  995.         
  996.         Connection connectionSQL = null;
  997.         try {
  998.             connectionSQL = getConnection();
  999.             
  1000.             String aliasNomeSA = "nomeSA";
  1001.             String aliasTipoSoggetto = "tipoSogg";
  1002.             String aliasNomeSoggetto = "nomeSogg";
  1003.             
  1004.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1005.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1006.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1007.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "idSA");
  1008.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "nome", aliasNomeSA);
  1009.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "tipo", "tipoSA");
  1010.             sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI, "tipo_soggetto", aliasTipoSoggetto);
  1011.             sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI, "nome_soggetto", aliasNomeSoggetto);
  1012.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, nomeColonnaPlain, ALIAS_PLAIN_VALUE);
  1013.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, nomeColonnaCodificata, ALIAS_ENC_VALUE);
  1014.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  1015.             sqlQueryObject.addWhereIsNotNullCondition(nomeColonnaPlain);
  1016.             if(!TipiDatabase.ORACLE.equals(this.tipoDatabase)) {
  1017.                 // In oracle le stringhe vuote equivalgono a null
  1018.                 sqlQueryObject.addWhereIsNotEmptyCondition(nomeColonnaPlain);
  1019.             }
  1020.             sqlQueryObject.addOrderBy(aliasTipoSoggetto);
  1021.             sqlQueryObject.addOrderBy(aliasNomeSoggetto);
  1022.             sqlQueryObject.addOrderBy(aliasNomeSA);
  1023.             sqlQueryObject.setANDLogicOperator(true);
  1024.             sqlQueryObject.setSelectDistinct(true);
  1025.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1026.             stmRead = connectionSQL.prepareStatement(sqlQuery);
  1027.             rs = stmRead.executeQuery();
  1028.             
  1029.             while(rs.next()){
  1030.                 
  1031.                 long idSA = rs.getLong("idSA");
  1032.                 String nome = rs.getString(aliasNomeSA);
  1033.                 String tipo = rs.getString("tipoSA");
  1034.                 String tipoSoggetto = rs.getString(aliasTipoSoggetto);
  1035.                 String nomeSoggetto = rs.getString(aliasNomeSoggetto);
  1036.                 String prefix = "["+nome+"][soggetto:"+tipoSoggetto+"/"+nomeSoggetto+"][tipoSA:"+tipo+"][idSA:"+idSA+"] '"+nomeColonnaPlain+"' ";
  1037.                 
  1038.                 VaultUpdateConfigPlainEnc c = new VaultUpdateConfigPlainEnc();
  1039.                 c.tabella = CostantiDB.SERVIZI_APPLICATIVI;
  1040.                 c.nomeColonnaPlain = nomeColonnaPlain;
  1041.                 c.nomeColonnaCodificata = nomeColonnaCodificata;
  1042.                 c.id = idSA;
  1043.                 updatePlainEncValue(connectionSQL, rs, ALIAS_PLAIN_VALUE, ALIAS_ENC_VALUE, 
  1044.                         prefix, output,
  1045.                         c);
  1046.             
  1047.             }
  1048.             
  1049.         } catch (Exception se) {
  1050.             throw new CoreException("[updateServiziApplicativi] failed: " + se.getMessage(),se);
  1051.         } finally {
  1052.             JDBCUtilities.closeResources(rs, stmRead);
  1053.             closeConnection(connectionSQL);
  1054.         }
  1055.     }
  1056.     
  1057.     
  1058.     
  1059.     
  1060.     
  1061.     
  1062.     
  1063.     
  1064.     
  1065.     
  1066.     // MESSAGE SECURITY
  1067.     
  1068.     private void updateMessageSecurity(String tabellaPadre, String tabella, 
  1069.             String nomeColonnaNomeProprieta, String nomeColonnaPlain, String nomeColonnaCodificata,
  1070.             String nomeProprieta, StringBuilder output) throws CoreException {
  1071.         PreparedStatement stmRead = null;
  1072.         ResultSet rs=null;
  1073.         
  1074.         Connection connectionSQL = null;
  1075.         try {
  1076.             connectionSQL = getConnection();
  1077.             
  1078.             String aliasIdSecProp = "idSecProp";
  1079.             String aliasIdPorta = "idP";
  1080.             String aliasNomePorta = "nomeP";
  1081.             
  1082.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1083.             sqlQueryObject.addFromTable(tabellaPadre);
  1084.             sqlQueryObject.addFromTable(tabella);
  1085.             sqlQueryObject.addSelectAliasField(tabellaPadre, "id", aliasIdPorta);
  1086.             sqlQueryObject.addSelectAliasField(tabellaPadre, "nome_porta", aliasNomePorta);
  1087.             sqlQueryObject.addSelectAliasField(tabella, "id", aliasIdSecProp);
  1088.             sqlQueryObject.addSelectAliasField(tabella, nomeColonnaPlain, ALIAS_PLAIN_VALUE);
  1089.             sqlQueryObject.addSelectAliasField(tabella, nomeColonnaCodificata, ALIAS_ENC_VALUE);
  1090.             sqlQueryObject.addWhereCondition(tabellaPadre+CONDITION_JOIN_ID+tabella+".id_porta");
  1091.             
  1092.             ISQLQueryObject sqlQueryObjectOrName = sqlQueryObject.newSQLQueryObject();
  1093.             sqlQueryObjectOrName.addFromTable(tabella);
  1094.             sqlQueryObjectOrName.addWhereCondition(tabella+"."+nomeColonnaNomeProprieta+" = ?");
  1095.             sqlQueryObjectOrName.addWhereLikeCondition(tabella+"."+nomeColonnaNomeProprieta, CostantiProprieta.KEY_PROPERTIES_CUSTOM_SEPARATOR+nomeProprieta, LikeConfig.endsWith(false)); // puo' contenere l'id del properties
  1096.             sqlQueryObjectOrName.addWhereLikeCondition(tabella+"."+nomeColonnaNomeProprieta, CostantiProprieta.KEY_PROPERTIES_DEFAULT_SEPARATOR+nomeProprieta, LikeConfig.endsWith(false)); // puo' contenere l'id del properties
  1097.             sqlQueryObjectOrName.setANDLogicOperator(false);
  1098.             sqlQueryObject.addWhereCondition(sqlQueryObjectOrName.createSQLConditions());

  1100.             sqlQueryObject.addWhereIsNotNullCondition(nomeColonnaPlain);
  1101.             if(!TipiDatabase.ORACLE.equals(this.tipoDatabase)) {
  1102.                 // In oracle le stringhe vuote equivalgono a null
  1103.                 sqlQueryObject.addWhereIsNotEmptyCondition(nomeColonnaPlain);
  1104.             }
  1105.             // campo clob, non gestito tramite condizione uguale su oracle
  1106.             /**sqlQueryObject.addWhereCondition(true, true, tabella+"."+nomeColonnaPlain+"='"+CostantiDB.MODIPA_VALUE_UNDEFINED+"'"); // vale anche per security properties*/
  1107.             sqlQueryObject.addWhereCondition(true, true, sqlQueryObject.getWhereLikeCondition(tabella+"."+nomeColonnaPlain, CostantiDB.MODIPA_VALUE_UNDEFINED, true)); // vale anche per security properties
  1108.                         
  1109.             sqlQueryObject.addOrderBy(aliasNomePorta);
  1110.             sqlQueryObject.setANDLogicOperator(true);
  1111.             sqlQueryObject.setSelectDistinct(true);
  1112.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1113.             stmRead = connectionSQL.prepareStatement(sqlQuery);
  1114.             stmRead.setString(1, nomeProprieta);
  1115.             rs = stmRead.executeQuery();

  1117.             while(rs.next()){
  1118.                 
  1119.                 long idSecProp = rs.getLong(aliasIdSecProp);
  1120.                 String nome = rs.getString(aliasNomePorta);
  1121.                 long idPorta = rs.getLong(aliasIdPorta);
  1122.                 String prefix = "["+nome+"][idPorta:"+idPorta+"][idSecProp:"+idSecProp+"] '"+nomeProprieta+"' ";
  1123.                 
  1124.                 VaultUpdateConfigPlainEnc c = new VaultUpdateConfigPlainEnc();
  1125.                 c.tabella = tabella;
  1126.                 c.nomeColonnaPlain = nomeColonnaPlain;
  1127.                 c.nomeColonnaCodificata = nomeColonnaCodificata;
  1128.                 c.id = idSecProp;
  1129.                 updatePlainEncValue(connectionSQL, rs, ALIAS_PLAIN_VALUE, ALIAS_ENC_VALUE, 
  1130.                         prefix, output,
  1131.                         c);
  1132.             
  1133.             }
  1134.             
  1135.         } catch (Exception se) {
  1136.             throw new CoreException("[updateMessageSecurity] failed: " + se.getMessage(),se);
  1137.         } finally {
  1138.             JDBCUtilities.closeResources(rs, stmRead);
  1139.             closeConnection(connectionSQL);
  1140.         }
  1141.     }
  1142.     
  1143.     
  1144.     
  1145.     
  1146.     
  1147.     
  1148.     
  1149.     
  1150.     
  1151.     // GENERIC PROPERTIES
  1152.     
  1153.     private void updateGenericProperties(String tipologia, String nomeProprieta, StringBuilder output) throws CoreException {
  1154.         PreparedStatement stmRead = null;
  1155.         ResultSet rs=null;
  1156.         
  1157.         Connection connectionSQL = null;
  1158.         try {
  1159.             connectionSQL = getConnection();
  1160.             
  1161.             String aliasNomeConfig = "nomeConfig";
  1162.             
  1163.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1164.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTY);
  1165.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTIES);
  1166.             sqlQueryObject.addSelectAliasField(CostantiDB.CONFIG_GENERIC_PROPERTY, "id", "idProp");
  1167.             sqlQueryObject.addSelectAliasField(CostantiDB.CONFIG_GENERIC_PROPERTIES, CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_NOME, aliasNomeConfig);
  1168.             sqlQueryObject.addSelectAliasField(CostantiDB.CONFIG_GENERIC_PROPERTY, CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_VALORE, ALIAS_PLAIN_VALUE);
  1169.             sqlQueryObject.addSelectAliasField(CostantiDB.CONFIG_GENERIC_PROPERTY, CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_ENC_VALUE, ALIAS_ENC_VALUE);
  1170.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_GENERIC_PROPERTIES+CONDITION_JOIN_ID+CostantiDB.CONFIG_GENERIC_PROPERTY+".id_props");
  1171.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_GENERIC_PROPERTIES+".tipo = ?");
  1172.             
  1173.             ISQLQueryObject sqlQueryObjectOrName = sqlQueryObject.newSQLQueryObject();
  1174.             sqlQueryObjectOrName.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTY);
  1175.             sqlQueryObjectOrName.addWhereCondition(CostantiDB.CONFIG_GENERIC_PROPERTY+"."+CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_NOME+" = ?");
  1176.             sqlQueryObjectOrName.addWhereLikeCondition(CostantiDB.CONFIG_GENERIC_PROPERTY+"."+CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_NOME, CostantiProprieta.KEY_PROPERTIES_CUSTOM_SEPARATOR+nomeProprieta, LikeConfig.endsWith(false)); // puo' contenere l'id del properties
  1177.             sqlQueryObjectOrName.addWhereLikeCondition(CostantiDB.CONFIG_GENERIC_PROPERTY+"."+CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_NOME, CostantiProprieta.KEY_PROPERTIES_DEFAULT_SEPARATOR+nomeProprieta, LikeConfig.endsWith(false)); // puo' contenere l'id del properties
  1178.             sqlQueryObjectOrName.setANDLogicOperator(false);
  1179.             sqlQueryObject.addWhereCondition(sqlQueryObjectOrName.createSQLConditions());
  1180.             
  1181.             sqlQueryObject.addWhereIsNotNullCondition(CostantiDB.CONFIG_GENERIC_PROPERTY+"."+CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_VALORE);
  1182.             if(!TipiDatabase.ORACLE.equals(this.tipoDatabase)) {
  1183.                 // In oracle le stringhe vuote equivalgono a null
  1184.                 sqlQueryObject.addWhereIsNotEmptyCondition(CostantiDB.CONFIG_GENERIC_PROPERTY+"."+CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_VALORE);
  1185.             }
  1186.             sqlQueryObject.addWhereCondition(true, true, CostantiDB.CONFIG_GENERIC_PROPERTY+"."+CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_VALORE+"='"+CostantiDB.MODIPA_VALUE_UNDEFINED+"'"); // vale anche per generic properties
  1187.             
  1188.             sqlQueryObject.addOrderBy(aliasNomeConfig);
  1189.             sqlQueryObject.setANDLogicOperator(true);
  1190.             /**sqlQueryObject.setSelectDistinct(true);*/ // Ritornando il field 'id' di CONFIG_GENERIC_PROPERTY il distinct non serve; lasciandolo si ottiene l'erore oracle: failed: ORA-00932: inconsistent datatypes: expected - got CLOB per via della colonna encValue ritornata  
  1191.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1192.             stmRead = connectionSQL.prepareStatement(sqlQuery);
  1193.             stmRead.setString(1, tipologia);
  1194.             stmRead.setString(2, nomeProprieta);
  1195.             rs = stmRead.executeQuery();

  1197.             while(rs.next()){
  1198.                 
  1199.                 long id = rs.getLong("idProp");
  1200.                 String nomeConfig = rs.getString(aliasNomeConfig);
  1201.                 String prefix = "[config:"+nomeConfig+"][tipo:"+tipologia+"][idGP:"+id+"] '"+nomeProprieta+"' ";
  1202.                 
  1203.                 VaultUpdateConfigPlainEnc c = new VaultUpdateConfigPlainEnc();
  1204.                 c.tabella = CostantiDB.CONFIG_GENERIC_PROPERTY;
  1205.                 c.nomeColonnaPlain = CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_VALORE;
  1206.                 c.nomeColonnaCodificata = CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_ENC_VALUE;
  1207.                 c.id = id;
  1208.                 updatePlainEncValue(connectionSQL, rs, ALIAS_PLAIN_VALUE, ALIAS_ENC_VALUE, 
  1209.                         prefix, output,
  1210.                         c);
  1211.                             
  1212.             }
  1213.             
  1214.         } catch (Exception se) {
  1215.             throw new CoreException("[updateGenericProperties] failed: " + se.getMessage(),se);
  1216.         } finally {
  1217.             JDBCUtilities.closeResources(rs, stmRead);
  1218.             closeConnection(connectionSQL);
  1219.         }
  1220.     }
  1221.     
  1222.     
  1223.     
  1224.     
  1225.     // PROTOCOL PROPERTIES
  1226.     
  1227.     private void updateProtocolProperties(String nomeProprieta, boolean binary, StringBuilder output) throws CoreException {
  1228.         PreparedStatement stmRead = null;
  1229.         ResultSet rs=null;
  1230.         
  1231.         Connection connectionSQL = null;
  1232.         try {
  1233.             connectionSQL = getConnection();
  1234.             
  1235.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1236.             sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  1237.             sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME+" = ?");
  1238.             if(binary) {
  1239.                 sqlQueryObject.addWhereIsNotNullCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BINARY);
  1240.             }
  1241.             else {
  1242.                 sqlQueryObject.addWhereIsNotNullCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING);
  1243.                 if(!TipiDatabase.ORACLE.equals(this.tipoDatabase)) {
  1244.                     // In oracle le stringhe vuote equivalgono a null
  1245.                     sqlQueryObject.addWhereIsNotEmptyCondition(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING);
  1246.                 }
  1247.                 sqlQueryObject.addWhereCondition(true, true, CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING+"='"+CostantiDB.MODIPA_VALUE_UNDEFINED+"'");
  1248.             }
  1249.             sqlQueryObject.setANDLogicOperator(true);
  1250.             sqlQueryObject.addOrderBy(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO);
  1251.             sqlQueryObject.addOrderBy(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO);
  1252.             sqlQueryObject.addOrderBy(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_NAME);
  1253.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1254.             stmRead = connectionSQL.prepareStatement(sqlQuery);
  1255.             stmRead.setString(1, nomeProprieta);
  1256.             rs = stmRead.executeQuery();
  1257.             
  1258.             IJDBCAdapter jdbcAdapter = null;
  1259.             if(binary) {
  1260.                 jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.tipoDatabase);
  1261.             }
  1262.             
  1263.             
  1264.             while(rs.next()){
  1265.                 
  1266.                 long id = rs.getLong(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID);
  1267.                 long idProprietario = rs.getLong(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_ID_PROPRIETARIO);
  1268.                 String proprietario = rs.getString(CostantiDB.PROTOCOL_PROPERTIES_COLUMN_TIPO_PROPRIETARIO);
  1269.                 
  1270.                 String identificativoOggetto = getIdentificativoOggettoProtocolProperties(proprietario,idProprietario, id);
  1271.                 
  1272.                 String prefix = "[tipoProprietario:"+proprietario+"][idProprietario:"+idProprietario+"]["+identificativoOggetto+"][idProp:"+id+"] '"+nomeProprieta+"' ";
  1273.                 
  1274.                 if(binary) {
  1275.                     VaultUpdateConfigValue c = new VaultUpdateConfigValue();
  1276.                     c.tabella = CostantiDB.PROTOCOL_PROPERTIES;
  1277.                     c.nomeColonna = CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BINARY;
  1278.                     c.id = id;
  1279.                     updateBinaryProtocolProperty(jdbcAdapter, connectionSQL, rs, CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_BINARY, 
  1280.                             prefix, output,
  1281.                             c);
  1282.                 }
  1283.                 else {
  1284.                     VaultUpdateConfigPlainEnc c = new VaultUpdateConfigPlainEnc();
  1285.                     c.tabella = CostantiDB.PROTOCOL_PROPERTIES;
  1286.                     c.nomeColonnaPlain = CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING;
  1287.                     c.nomeColonnaCodificata = CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_ENCODING_STRING;
  1288.                     c.id = id;
  1289.                     updatePlainEncValue(connectionSQL, rs, CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_STRING, CostantiDB.PROTOCOL_PROPERTIES_COLUMN_VALUE_ENCODING_STRING, 
  1290.                             prefix, output,
  1291.                             c);
  1292.                 }
  1293.             
  1294.             }
  1295.             
  1296.         } catch (Exception se) {
  1297.             throw new CoreException("[updateProtocolProperties] failed: " + se.getMessage(),se);
  1298.         } finally {
  1299.             JDBCUtilities.closeResources(rs, stmRead);
  1300.             closeConnection(connectionSQL);
  1301.         }
  1302.     }
  1303.     private String getIdentificativoOggettoProtocolProperties(String proprietario, long id, long idProp) throws CoreException {
  1304.         PreparedStatement stmRead = null;
  1305.         ResultSet rs=null;
  1306.         
  1307.         Connection connectionSQL = null;
  1308.         try {
  1309.             connectionSQL = getConnection();        
  1310.         
  1311.             ProprietariProtocolProperty proprietarioProtocolProperty = ProprietariProtocolProperty.valueOf(proprietario);
  1312.             
  1313.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1314.             addTableProtocolProperties(sqlQueryObject, proprietarioProtocolProperty);
  1315.             sqlQueryObject.addWhereCondition(CONDITION_WHERE_ID);
  1316.             sqlQueryObject.setANDLogicOperator(true);
  1317.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1318.             stmRead = connectionSQL.prepareStatement(sqlQuery);
  1319.             stmRead.setLong(1, id);
  1320.             rs = stmRead.executeQuery();
  1321.             if(rs.next()){
  1322.                 return readInfoProtocolProperties(connectionSQL, rs, proprietarioProtocolProperty);
  1323.             }
  1324.             throw new CoreException("Entry not found for (idProp:"+idProp+") '"+proprietarioProtocolProperty+"' ("+sqlQuery+" id:"+id+")");
  1325.         
  1326.         } catch (Exception se) {
  1327.             throw new CoreException(se.getMessage(),se);
  1328.         } finally {
  1329.             JDBCUtilities.closeResources(rs, stmRead);
  1330.             closeConnection(connectionSQL);
  1331.         }
  1332.         
  1333.     }
  1334.     private void addTableProtocolProperties(ISQLQueryObject sqlQueryObject, ProprietariProtocolProperty proprietarioProtocolProperty) throws SQLQueryObjectException {
  1335.         switch(proprietarioProtocolProperty) {
  1336.         case ACCORDO_COOPERAZIONE:
  1337.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_COOPERAZIONE);
  1338.             break;
  1339.         case ACCORDO_SERVIZIO_PARTE_COMUNE:
  1340.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  1341.             break;
  1342.         case ACCORDO_SERVIZIO_PARTE_SPECIFICA:
  1343.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1344.             break;
  1345.         case AZIONE_ACCORDO:
  1346.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_AZIONI);
  1347.             break;
  1348.         case OPERATION:
  1349.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  1350.             break;
  1351.         case PORT_TYPE:
  1352.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  1353.             break;
  1354.         case RESOURCE:
  1355.             sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES);
  1356.             break;
  1357.         case FRUITORE:
  1358.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  1359.             break;
  1360.         case SERVIZIO_APPLICATIVO:
  1361.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1362.             break;
  1363.         case SOGGETTO:
  1364.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1365.             break;
  1366.         default:
  1367.             break;
  1368.     }
  1369.     }
  1370.     private String readInfoProtocolProperties(Connection connectionSQL, ResultSet rs, ProprietariProtocolProperty proprietarioProtocolProperty) throws SQLException, CoreException, DriverRegistroServiziException {
  1371.         switch(proprietarioProtocolProperty) {
  1372.         case ACCORDO_COOPERAZIONE:{
  1373.             return rs.getString("nome");
  1374.         }
  1375.         case ACCORDO_SERVIZIO_PARTE_COMUNE:{
  1376.             String nome = rs.getString("nome");
  1377.             long idSoggetto = rs.getLong(CostantiDB.ACCORDI_COLUMN_ID_REFERENTE_REF);
  1378.             int versione = rs.getInt("versione");
  1379.             IDSoggetto idS = DBUtils.getIdSoggetto(idSoggetto, connectionSQL, this.tipoDatabase);
  1380.             return IDAccordoFactory.getInstance().getUriFromValues(nome, idS, versione);
  1381.         }
  1382.         case ACCORDO_SERVIZIO_PARTE_SPECIFICA:{
  1383.             String tipoServizio = rs.getString("tipo_servizio");
  1384.             String nomeServizio = rs.getString("nome_servizio");
  1385.             int versioneServizio = rs.getInt("versione_servizio");
  1386.             long idSoggetto = rs.getLong(CostantiDB.SERVIZI_COLUMN_ID_SOGGETTO_REF);
  1387.             IDSoggetto idS = DBUtils.getIdSoggetto(idSoggetto, connectionSQL, this.tipoDatabase);
  1388.             return IDServizioFactory.getInstance().getUriFromValues(tipoServizio, nomeServizio, idS, versioneServizio);
  1389.         }
  1390.         case AZIONE_ACCORDO:{
  1391.             String nome = rs.getString("nome");
  1392.             long idAccordo = rs.getLong(CostantiDB.ACCORDI_COLUMN_ID_ACCORDO_REF);
  1393.             return "api:"+readDatiAccordo(connectionSQL, idAccordo) + " azione:"+nome;
  1394.         }
  1395.         case OPERATION:{
  1396.             String nome = rs.getString("nome");
  1397.             long idPortType = rs.getLong("id_port_type");
  1398.             return "api:"+readDatiPT(connectionSQL, idPortType) + " operation:"+nome;
  1399.         }
  1400.         case PORT_TYPE:{
  1401.             String nome = rs.getString("nome");
  1402.             long idAccordo = rs.getLong(CostantiDB.ACCORDI_COLUMN_ID_ACCORDO_REF);
  1403.             return "api:"+readDatiAccordo(connectionSQL, idAccordo) + " portType:"+nome;
  1404.         }
  1405.         case RESOURCE:{
  1406.             String nome = rs.getString("nome");
  1407.             long idAccordo = rs.getLong(CostantiDB.ACCORDI_COLUMN_ID_ACCORDO_REF);
  1408.             return "api:"+readDatiAccordo(connectionSQL, idAccordo) + " resource:"+nome;
  1409.         }
  1410.         case FRUITORE:{
  1411.             long idServizio = rs.getLong("id_servizio");
  1412.             long idSoggetto = rs.getLong(CostantiDB.SERVIZI_COLUMN_ID_SOGGETTO_REF);
  1413.             IDSoggetto idS = DBUtils.getIdSoggetto(idSoggetto, connectionSQL, this.tipoDatabase);
  1414.             return idS.toString() +" -> " + readDatiServizio(connectionSQL, idServizio);
  1415.         }
  1416.         case SERVIZIO_APPLICATIVO:{
  1417.             String nome = rs.getString("nome");
  1418.             long idSoggetto = rs.getLong("id_soggetto");
  1419.             IDSoggetto idS = DBUtils.getIdSoggetto(idSoggetto, connectionSQL, this.tipoDatabase);
  1420.             return idS.toString()+" sa:"+nome;
  1421.         }
  1422.         case SOGGETTO:{
  1423.             String tipoSoggetto = rs.getString("tipo_soggetto");
  1424.             String nomeSoggetto = rs.getString("nome_soggetto");
  1425.             return new IDSoggetto(tipoSoggetto, nomeSoggetto).toString();
  1426.         }
  1427.         default:
  1428.             break;
  1429.         }
  1430.         return null;
  1431.     }
  1432.     
  1433.     
  1434.     
  1435.     
  1436.     // PROPERTIES
  1437.     
  1438.     private void updateProperties(String tabella, String nomeColonna, String nomeColonnaPlain, String nomeColonnaCodificata, StringBuilder output,
  1439.             boolean checkRequestSec, boolean checkResponseCheck) throws CoreException {
  1440.         PreparedStatement stmRead = null;
  1441.         ResultSet rs=null;
  1442.         
  1443.         Connection connectionSQL = null;
  1444.         try {
  1445.             connectionSQL = getConnection();
  1446.             
  1447.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1448.             sqlQueryObject.addFromTable(tabella);
  1449.             sqlQueryObject.addWhereIsNotNullCondition(nomeColonnaCodificata);
  1450.             if(!TipiDatabase.ORACLE.equals(this.tipoDatabase)) {
  1451.                 // In oracle le stringhe vuote equivalgono a null
  1452.                 sqlQueryObject.addWhereIsNotEmptyCondition(nomeColonnaCodificata);
  1453.             }
  1454.             sqlQueryObject.addOrderBy(nomeColonna);
  1455.             sqlQueryObject.setANDLogicOperator(true);
  1456.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1457.             stmRead = connectionSQL.prepareStatement(sqlQuery);
  1458.             rs = stmRead.executeQuery();
  1459.             
  1460.             while(rs.next()){
  1461.                 
  1462.                 long idP = rs.getLong("id");
  1463.                 String nomeProprieta = rs.getString(nomeColonna);
  1464.                 
  1465.                 if(checkRequestSec || checkResponseCheck) {
  1466.                     long idPorta = rs.getLong(CostantiDB.PORTA_COLUMN_ID_REF);
  1467.                     String tabellaPorta = CostantiDB.PORTE_DELEGATE;
  1468.                     if(CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST.equals(tabella) ||
  1469.                             CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE.equals(tabella)) {
  1470.                         tabellaPorta = CostantiDB.PORTE_APPLICATIVE;
  1471.                     }
  1472.                     String sec = readMessageSecurityPorta(connectionSQL, idPorta, tabellaPorta, checkRequestSec);
  1473.                     if(sec!=null && StringUtils.isNotEmpty(sec) && !"-".equals(sec) && !CostantiDB.SICUREZZA_MESSAGGIO_SCHEMA_DEFAULT.equals(sec)) {
  1474.                         // viene gestita con il processamento specifico delle proprietà fatto in precedenza
  1475.                         continue;
  1476.                     }
  1477.                 }
  1478.                 
  1479.                 String identificativoOggetto = getIdentificativoOggettoProperties(tabella,connectionSQL,rs);
  1480.                 
  1481.                 String prefix = "[proprietario:"+tabella+"]["+identificativoOggetto+"][idProp:"+idP+"] '"+nomeProprieta+"' ";
  1482.                 
  1483.                 VaultUpdateConfigPlainEnc c = new VaultUpdateConfigPlainEnc();
  1484.                 c.tabella = tabella;
  1485.                 c.nomeColonnaPlain = nomeColonnaPlain;
  1486.                 c.nomeColonnaCodificata = nomeColonnaCodificata;
  1487.                 c.id = idP;
  1488.                 
  1489.                 updatePlainEncValue(connectionSQL, rs, nomeColonnaPlain, nomeColonnaCodificata, 
  1490.                         prefix, output,
  1491.                         c);
  1492.             
  1493.             }
  1494.             
  1495.         } catch (Exception se) {
  1496.             throw new CoreException("[updateProperties-"+tabella+"] failed: " + se.getMessage(),se);
  1497.         } finally {
  1498.             JDBCUtilities.closeResources(rs, stmRead);
  1499.             closeConnection(connectionSQL);
  1500.         }
  1501.     }
  1502.     private String getIdentificativoOggettoProperties(String tabella, Connection connectionSQL, ResultSet rs) throws SQLException, CoreException {
  1503.         if(CostantiDB.SOGGETTI_PROPS.equals(tabella)) {
  1504.             long idSoggetto = rs.getLong("id_soggetto");
  1505.             IDSoggetto idS = DBUtils.getIdSoggetto(idSoggetto, connectionSQL, this.tipoDatabase);
  1506.             return idS.toString();
  1507.         }
  1508.         else if(CostantiDB.SERVIZI_APPLICATIVI_PROPS.equals(tabella)) {
  1509.             long idSA = rs.getLong("id_servizio_applicativo");
  1510.             return readDatiSA(connectionSQL, idSA);
  1511.         }
  1512.         else if(CostantiDB.SYSTEM_PROPERTIES_PDD.equals(tabella)) {
  1513.             return "configurazione-generale";
  1514.         }
  1515.         else if(CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST.equals(tabella) ||
  1516.                 CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE.equals(tabella) ||
  1517.                 CostantiDB.PORTE_APPLICATIVE_AUTENTICAZIONE_PROP.equals(tabella) ||
  1518.                 CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_PROP.equals(tabella) ||
  1519.                 CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_CONTENUTI_PROP.equals(tabella) ||
  1520.                 CostantiDB.PORTE_APPLICATIVE_PROP.equals(tabella)) {
  1521.             long idPorta = rs.getLong(CostantiDB.PORTA_COLUMN_ID_REF);
  1522.             return readDatiPortaApplicativa(connectionSQL, idPorta);
  1523.         }
  1524.         else if(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST.equals(tabella) ||
  1525.                 CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE.equals(tabella) ||
  1526.                 CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP.equals(tabella) ||
  1527.                 CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP.equals(tabella) ||
  1528.                 CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP.equals(tabella) ||
  1529.                 CostantiDB.PORTE_DELEGATE_PROP.equals(tabella)) {
  1530.             long idPorta = rs.getLong(CostantiDB.PORTA_COLUMN_ID_REF);
  1531.             return readDatiPortaDelegata(connectionSQL, idPorta);
  1532.         }
  1533.         return null;
  1534.         
  1535.     }
  1536.     
  1537.     
  1538.     
  1539.     // READ UTILS
  1540.         
  1541.     private String readDatiAccordo(Connection connectionSQL, long idAccordo) throws CoreException {
  1542.         PreparedStatement stmReadInternal = null;
  1543.         ResultSet rsInternal=null;
  1544.         try {
  1545.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1546.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  1547.             sqlQueryObject.addWhereCondition(CONDITION_WHERE_ID);
  1548.             sqlQueryObject.setANDLogicOperator(true);
  1549.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1550.             stmReadInternal = connectionSQL.prepareStatement(sqlQuery);
  1551.             stmReadInternal.setLong(1, idAccordo);
  1552.             rsInternal = stmReadInternal.executeQuery();
  1553.             String nome = rsInternal.getString("nome");
  1554.             if(rsInternal.next()) {
  1555.                 long idSoggetto = rsInternal.getLong(CostantiDB.ACCORDI_COLUMN_ID_REFERENTE_REF);
  1556.                 int versione = rsInternal.getInt("versione");
  1557.                 IDSoggetto idS = DBUtils.getIdSoggetto(idSoggetto, connectionSQL, this.tipoDatabase);
  1558.                 return IDAccordoFactory.getInstance().getUriFromValues(nome, idS, versione);
  1559.             }
  1560.             return null;
  1561.         } catch (Exception se) {
  1562.             throw new CoreException(se.getMessage(),se);
  1563.         } finally {
  1564.             JDBCUtilities.closeResources(rsInternal, stmReadInternal);
  1565.         }
  1566.     }
  1567.     private String readDatiPT(Connection connectionSQL, long idPortType) throws CoreException {
  1568.         PreparedStatement stmReadInternal = null;
  1569.         ResultSet rsInternal=null;
  1570.         try {
  1571.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1572.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  1573.             sqlQueryObject.addWhereCondition(CONDITION_WHERE_ID);
  1574.             sqlQueryObject.setANDLogicOperator(true);
  1575.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1576.             stmReadInternal = connectionSQL.prepareStatement(sqlQuery);
  1577.             stmReadInternal.setLong(1, idPortType);
  1578.             rsInternal = stmReadInternal.executeQuery();
  1579.             if(rsInternal.next()) {
  1580.                 String nome = rsInternal.getString("nome");
  1581.                 long idAccordo = rsInternal.getLong(CostantiDB.ACCORDI_COLUMN_ID_ACCORDO_REF);
  1582.                 return readDatiAccordo(connectionSQL, idAccordo) + " portType:"+nome;
  1583.             }
  1584.             return null;
  1585.         } catch (Exception se) {
  1586.             throw new CoreException(se.getMessage(),se);
  1587.         } finally {
  1588.             JDBCUtilities.closeResources(rsInternal, stmReadInternal);
  1589.         }
  1590.     }
  1591.     private String readDatiServizio(Connection connectionSQL, long idServizio) throws CoreException {
  1592.         PreparedStatement stmReadInternal = null;
  1593.         ResultSet rsInternal=null;
  1594.         try {
  1595.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1596.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1597.             sqlQueryObject.addWhereCondition(CONDITION_WHERE_ID);
  1598.             sqlQueryObject.setANDLogicOperator(true);
  1599.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1600.             stmReadInternal = connectionSQL.prepareStatement(sqlQuery);
  1601.             stmReadInternal.setLong(1, idServizio);
  1602.             rsInternal = stmReadInternal.executeQuery();
  1603.             if(rsInternal.next()) {
  1604.                 String tipoServizio = rsInternal.getString("tipo_servizio");
  1605.                 String nomeServizio = rsInternal.getString("nome_servizio");
  1606.                 int versioneServizio = rsInternal.getInt("versione_servizio");
  1607.                 long idSoggetto = rsInternal.getLong(CostantiDB.SERVIZI_COLUMN_ID_SOGGETTO_REF);
  1608.                 IDSoggetto idS = DBUtils.getIdSoggetto(idSoggetto, connectionSQL, this.tipoDatabase);
  1609.                 return IDServizioFactory.getInstance().getUriFromValues(tipoServizio, nomeServizio, idS, versioneServizio);
  1610.             }
  1611.             return null;
  1612.         } catch (Exception se) {
  1613.             throw new CoreException(se.getMessage(),se);
  1614.         } finally {
  1615.             JDBCUtilities.closeResources(rsInternal, stmReadInternal);
  1616.         }
  1617.     }
  1618.     private String readDatiSA(Connection connectionSQL, long idServizioApplicativo) throws CoreException {
  1619.         PreparedStatement stmReadInternal = null;
  1620.         ResultSet rsInternal=null;
  1621.         try {
  1622.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1623.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1624.             sqlQueryObject.addWhereCondition(CONDITION_WHERE_ID);
  1625.             sqlQueryObject.setANDLogicOperator(true);
  1626.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1627.             stmReadInternal = connectionSQL.prepareStatement(sqlQuery);
  1628.             stmReadInternal.setLong(1, idServizioApplicativo);
  1629.             rsInternal = stmReadInternal.executeQuery();
  1630.             if(rsInternal.next()) {
  1631.                 String nome = rsInternal.getString("nome");
  1632.                 long idSoggetto = rsInternal.getLong(CostantiDB.SERVIZI_APPLICATIVI_COLUMN_ID_SOGGETTO);
  1633.                 IDSoggetto idS = DBUtils.getIdSoggetto(idSoggetto, connectionSQL, this.tipoDatabase);
  1634.                 return idS.toString()+" sa:"+nome;
  1635.             }
  1636.             return null;
  1637.         } catch (Exception se) {
  1638.             throw new CoreException(se.getMessage(),se);
  1639.         } finally {
  1640.             JDBCUtilities.closeResources(rsInternal, stmReadInternal);
  1641.         }
  1642.     }
  1643.     private String readDatiPortaDelegata(Connection connectionSQL, long idPorta) throws CoreException {
  1644.         return readDatiPorta(connectionSQL, idPorta, CostantiDB.PORTE_DELEGATE) ;
  1645.     }
  1646.     private String readDatiPortaApplicativa(Connection connectionSQL, long idPorta) throws CoreException {
  1647.         return readDatiPorta(connectionSQL, idPorta, CostantiDB.PORTE_APPLICATIVE) ;
  1648.     }
  1649.     private String readDatiPorta(Connection connectionSQL, long idPorta, String tabella) throws CoreException {
  1650.         PreparedStatement stmReadInternal = null;
  1651.         ResultSet rsInternal=null;
  1652.         try {
  1653.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1654.             sqlQueryObject.addFromTable(tabella);
  1655.             sqlQueryObject.addWhereCondition(CONDITION_WHERE_ID);
  1656.             sqlQueryObject.setANDLogicOperator(true);
  1657.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1658.             stmReadInternal = connectionSQL.prepareStatement(sqlQuery);
  1659.             stmReadInternal.setLong(1, idPorta);
  1660.             rsInternal = stmReadInternal.executeQuery();
  1661.             if(rsInternal.next()) {
  1662.                 return rsInternal.getString("nome_porta");
  1663.             }
  1664.             return null;
  1665.         } catch (Exception se) {
  1666.             throw new CoreException(se.getMessage(),se);
  1667.         } finally {
  1668.             JDBCUtilities.closeResources(rsInternal, stmReadInternal);
  1669.         }
  1670.     }
  1671.     private String readMessageSecurityPorta(Connection connectionSQL, long idPorta, String tabella, boolean request) throws CoreException {
  1672.         PreparedStatement stmReadInternal = null;
  1673.         ResultSet rsInternal=null;
  1674.         try {
  1675.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1676.             sqlQueryObject.addFromTable(tabella);
  1677.             sqlQueryObject.addWhereCondition(CONDITION_WHERE_ID);
  1678.             sqlQueryObject.setANDLogicOperator(true);
  1679.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1680.             stmReadInternal = connectionSQL.prepareStatement(sqlQuery);
  1681.             stmReadInternal.setLong(1, idPorta);
  1682.             rsInternal = stmReadInternal.executeQuery();
  1683.             if(rsInternal.next()) {
  1684.                 return rsInternal.getString(request ? "security_request_mode" : "security_response_mode");
  1685.             }
  1686.             return null;
  1687.         } catch (Exception se) {
  1688.             throw new CoreException(se.getMessage(),se);
  1689.         } finally {
  1690.             JDBCUtilities.closeResources(rsInternal, stmReadInternal);
  1691.         }
  1692.     }
  1693. }

  1695. class VaultUpdateConfigPlainEnc{
  1696.     
  1697.     String tabella;
  1698.     String nomeColonnaPlain;
  1699.     String nomeColonnaCodificata;
  1700.     long id;
  1701.     
  1702. }

  1704. class VaultUpdateConfigValue{
  1705.     
  1706.     String tabella;
  1707.     String nomeColonna;
  1708.     long id;
  1709.     
  1710. }
Created with JaCoCo 0.8.8.202204050719