DriverConfigurazioneDB_connettoriLIB.java

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

  22. import static org.openspcoop2.core.constants.CostantiDB.CREATE;
  23. import static org.openspcoop2.core.constants.CostantiDB.DELETE;
  24. import static org.openspcoop2.core.constants.CostantiDB.UPDATE;

  26. import java.sql.Connection;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.SQLException;
  30. import java.sql.Types;
  31. import java.util.ArrayList;
  32. import java.util.HashMap;
  33. import java.util.List;
  34. import java.util.Map;

  36. import org.apache.commons.lang.StringUtils;
  37. import org.openspcoop2.core.byok.BYOKWrappedValue;
  38. import org.openspcoop2.core.byok.IDriverBYOK;
  39. import org.openspcoop2.core.commons.DBUtils;
  40. import org.openspcoop2.core.config.Connettore;
  41. import org.openspcoop2.core.config.Property;
  42. import org.openspcoop2.core.config.driver.ConnettorePropertiesUtilities;
  43. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  44. import org.openspcoop2.core.constants.CostantiConnettori;
  45. import org.openspcoop2.core.constants.CostantiDB;
  46. import org.openspcoop2.core.constants.TipiConnettore;
  47. import org.openspcoop2.utils.UtilsException;
  48. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  49. import org.openspcoop2.utils.sql.ISQLQueryObject;
  50. import org.openspcoop2.utils.sql.SQLObjectFactory;

  52. /**
  53.  * DriverConfigurazioneDB_connettoriLIB
  54.  * 
  55.  * @author Stefano Corallo - corallo@link.it
  56.  * @author $Author$
  57.  * @version $Rev$, $Date$
  58.  */
  59. public class DriverConfigurazioneDB_connettoriLIB {


  62.     /**
  63.      * CRUD oggetto Connettore. In caso di CREATE inserisce nel db il dati del
  64.      * connettore passato e ritorna l'id dell'oggetto creato Non si occupa di
  65.      * chiudere la connessione con il db in caso di errore in quanto verra'
  66.      * gestita dal metodo chiamante
  67.      * 
  68.      * @param type
  69.      *            Tipo operazione {1 (CREATE),2 (UPDATE),3 (DELETE)}
  70.      * @param connettore
  71.      * @return id del connettore in caso di type 1 (CREATE)
  72.      */
  73.     public static long CRUDConnettore(int type, Connettore connettore, Connection connection, IDriverBYOK driverBYOK) throws DriverConfigurazioneException {
  74.         PreparedStatement stm = null;
  75.         ResultSet rs=null;
  76.         String sqlQuery;

  78.         if(connettore == null) throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConnettore] L'oggetto Connettore non puo essere null");
  79.         if (type!=CostantiDB.DELETE &&
  80.             (connettore.getNome() == null || connettore.getNome().trim().equals(""))
  81.             ){
  82.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConnettore]Il nome Connettore non puo essere null");
  83.         }
  84.         // il tipo di connettore (http, jms, disabilitato o altro)
  85.         String nomeConnettore = connettore.getNome();
  86.         String endpointtype = connettore.getTipo();

  88.         if (endpointtype == null || endpointtype.trim().equals(""))
  89.             endpointtype = TipiConnettore.DISABILITATO.getNome();

  91.         String url = null;// in caso di tipo http
  92.         boolean debug = false;
  93.         String nome = null; // jms
  94.         String tipo = null; // jms
  95.         String utente = null;// jms
  96.         String password = null;// jms
  97.         String initcont = null;// jms
  98.         String urlpkg = null;// jms
  99.         String provurl = null;// jms
  100.         String connectionfactory = null;// jms
  101.         String sendas = null;// jms

  103.         String transferMode = null; // in caso di tipo http e https
  104.         Integer transferModeChunkSize = null; // in caso di tipo http e https

  106.         boolean proxy = false;
  107.         String proxyType = null;
  108.         String proxyHostname = null;
  109.         String proxyPort = null;
  110.         String proxyUsername = null;
  111.         String proxyPassword = null;
  112.         
  113.         Integer tempiRispostaConnectionTimeout = null;
  114.         Integer tempiRispostaReadTimeout = null;
  115.         Integer tempiRispostaAvgResponseTime = null;

  117.         String redirectMode = null; // in caso di tipo http e https
  118.         Integer redirectMaxHop = null; // in caso di tipo http e https
  119.         
  120.         String tokenPolicy = null;
  121.         
  122.         String apiKey = null;
  123.         String apiKeyHeader = null;
  124.         String appId = null;
  125.         String appIdHeader = null;
  126.         
  127.         boolean isAbilitato = false;

  129.         Map<String, String> extendedProperties = new HashMap<>();
  130.         
  131.         List<String> propertiesGestiteAttraversoColonneAdHoc = new ArrayList<>();
  132.         
  133.         // setto i dati, se le property non sono presenti il loro valore rimarra
  134.         // a null e verra settato come tale nel DB
  135.         String nomeProperty = null;
  136.         String valoreProperty = null;
  137.         for (int i = 0; i < connettore.sizePropertyList(); i++) {
  138.             nomeProperty = connettore.getProperty(i).getNome();

  140.             valoreProperty = connettore.getProperty(i).getValore();
  141.             if (valoreProperty != null && valoreProperty.equals(""))
  142.                 valoreProperty = null;

  144.             // Debug
  145.             if (nomeProperty.equals(CostantiDB.CONNETTORE_DEBUG) &&
  146.                 "true".equals(valoreProperty)){
  147.                 debug=true;
  148.             }
  149.             
  150.             // Proxy
  151.             if (nomeProperty.equals(CostantiDB.CONNETTORE_PROXY_TYPE)){
  152.                 proxy = true;
  153.                 proxyType = valoreProperty;
  154.                 
  155.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  156.                 
  157.                 // cerco altri valori del proxy
  158.                 for (Property propertyCheck: connettore.getPropertyList()) {
  159.                     if (propertyCheck.getNome().equals(CostantiDB.CONNETTORE_PROXY_HOSTNAME)){
  160.                         propertiesGestiteAttraversoColonneAdHoc.add(propertyCheck.getNome());
  161.                         proxyHostname = propertyCheck.getValore();
  162.                     }
  163.                     if (propertyCheck.getNome().equals(CostantiDB.CONNETTORE_PROXY_PORT)){
  164.                         propertiesGestiteAttraversoColonneAdHoc.add(propertyCheck.getNome());
  165.                         proxyPort = propertyCheck.getValore();
  166.                     }
  167.                     if (propertyCheck.getNome().equals(CostantiDB.CONNETTORE_PROXY_USERNAME)){
  168.                         propertiesGestiteAttraversoColonneAdHoc.add(propertyCheck.getNome());
  169.                         proxyUsername = propertyCheck.getValore();
  170.                     }
  171.                     if (propertyCheck.getNome().equals(CostantiDB.CONNETTORE_PROXY_PASSWORD)){
  172.                         propertiesGestiteAttraversoColonneAdHoc.add(propertyCheck.getNome());
  173.                         proxyPassword = propertyCheck.getValore();
  174.                     }
  175.                 }
  176.             }
  177.             
  178.             // Tempi Risposta
  179.             if (nomeProperty.equals(CostantiDB.CONNETTORE_CONNECTION_TIMEOUT)){
  180.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  181.                 tempiRispostaConnectionTimeout = Integer.parseInt(valoreProperty);
  182.             }
  183.             if (nomeProperty.equals(CostantiDB.CONNETTORE_READ_CONNECTION_TIMEOUT)){
  184.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  185.                 tempiRispostaReadTimeout = Integer.parseInt(valoreProperty);
  186.             }
  187.             if (nomeProperty.equals(CostantiDB.CONNETTORE_TEMPO_MEDIO_RISPOSTA)){
  188.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  189.                 tempiRispostaAvgResponseTime = Integer.parseInt(valoreProperty);
  190.             }
  191.             
  192.             // TransferMode
  193.             if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_DATA_TRANSFER_MODE)){
  194.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  195.                 transferMode = valoreProperty;
  196.             }
  197.             if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_DATA_TRANSFER_MODE_CHUNK_SIZE)){
  198.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  199.                 transferModeChunkSize = Integer.parseInt(valoreProperty);
  200.             }
  201.             
  202.             // RedirectMode
  203.             if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_REDIRECT_FOLLOW)){
  204.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  205.                 redirectMode = valoreProperty;
  206.             }
  207.             if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_REDIRECT_MAX_HOP)){
  208.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  209.                 redirectMaxHop = Integer.parseInt(valoreProperty);
  210.             }
  211.             
  212.             // TokenPolicy
  213.             if (nomeProperty.equals(CostantiDB.CONNETTORE_TOKEN_POLICY)){
  214.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  215.                 tokenPolicy = valoreProperty;
  216.             }
  217.             
  218.             // ApiKey
  219.             if (nomeProperty.equals(CostantiDB.CONNETTORE_APIKEY)){
  220.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  221.                 apiKey = valoreProperty;
  222.             }
  223.             if (nomeProperty.equals(CostantiDB.CONNETTORE_APIKEY_HEADER)){
  224.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  225.                 apiKeyHeader = valoreProperty;
  226.             }
  227.             if (nomeProperty.equals(CostantiDB.CONNETTORE_APIKEY_APPID)){
  228.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  229.                 appId = valoreProperty;
  230.             }
  231.             if (nomeProperty.equals(CostantiDB.CONNETTORE_APIKEY_APPID_HEADER)){
  232.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  233.                 appIdHeader = valoreProperty;
  234.             }

  236.             if(TipiConnettore.HTTP.getNome().equals(endpointtype)){
  237.                 if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_LOCATION))
  238.                     url = valoreProperty;
  239.             }
  240.             else if(TipiConnettore.JMS.getNome().equals(endpointtype)){
  241.                 if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_NOME))
  242.                     nome = valoreProperty;
  243.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_TIPO))
  244.                     tipo = valoreProperty;
  245.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_USER))
  246.                     utente = valoreProperty;
  247.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_PWD))
  248.                     password = valoreProperty;
  249.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_FACTORY_INITIAL))
  250.                     initcont = valoreProperty;
  251.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_FACTORY_URL_PKG))
  252.                     urlpkg = valoreProperty;
  253.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_PROVIDER_URL))
  254.                     provurl = valoreProperty;
  255.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_CONNECTION_FACTORY))
  256.                     connectionfactory = valoreProperty;
  257.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_SEND_AS))
  258.                     sendas = valoreProperty;
  259.             }

  261.             // se endpointype != disabilitato allora lo setto abilitato
  262.             if (!endpointtype.equalsIgnoreCase(TipiConnettore.DISABILITATO.getNome()))
  263.                 isAbilitato = true;
  264.             
  265.             // extendedProperties
  266.             if(nomeProperty.startsWith(CostantiConnettori.CONNETTORE_EXTENDED_PREFIX)){
  267.                 extendedProperties.put(nomeProperty, valoreProperty);
  268.             }

  270.         }

  272.         try {

  274.             long idConnettore = 0;
  275.             int n = 0;
  276.             switch (type) {
  277.             case CREATE:

  279.                 // create
  280.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  281.                 sqlQueryObject.addInsertTable(CostantiDB.CONNETTORI);
  282.                 sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_COLUMN_ENDPOINT_TYPE, "?");
  283.                 sqlQueryObject.addInsertField("url", "?");
  284.                 sqlQueryObject.addInsertField("transfer_mode", "?");
  285.                 sqlQueryObject.addInsertField("transfer_mode_chunk_size", "?");
  286.                 sqlQueryObject.addInsertField("redirect_mode", "?");
  287.                 sqlQueryObject.addInsertField("redirect_max_hop", "?");
  288.                 sqlQueryObject.addInsertField("nome", "?");
  289.                 sqlQueryObject.addInsertField("tipo", "?");
  290.                 sqlQueryObject.addInsertField("utente", "?");
  291.                 sqlQueryObject.addInsertField("password", "?");
  292.                 sqlQueryObject.addInsertField("enc_password", "?");
  293.                 sqlQueryObject.addInsertField("initcont", "?");
  294.                 sqlQueryObject.addInsertField("urlpkg", "?");
  295.                 sqlQueryObject.addInsertField("provurl", "?");
  296.                 sqlQueryObject.addInsertField("connection_factory", "?");
  297.                 sqlQueryObject.addInsertField("send_as", "?");
  298.                 sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_COLUMN_NOME, "?");
  299.                 sqlQueryObject.addInsertField("debug", "?");                
  300.                 sqlQueryObject.addInsertField("proxy", "?");        
  301.                 sqlQueryObject.addInsertField("proxy_type", "?");       
  302.                 sqlQueryObject.addInsertField("proxy_hostname", "?");       
  303.                 sqlQueryObject.addInsertField("proxy_port", "?");       
  304.                 sqlQueryObject.addInsertField("proxy_username", "?");       
  305.                 sqlQueryObject.addInsertField("proxy_password", "?");   
  306.                 sqlQueryObject.addInsertField("enc_proxy_password", "?");
  307.                 sqlQueryObject.addInsertField("connection_timeout", "?");       
  308.                 sqlQueryObject.addInsertField("read_timeout", "?");     
  309.                 sqlQueryObject.addInsertField("avg_response_time", "?");        
  310.                 sqlQueryObject.addInsertField("custom", "?");
  311.                 sqlQueryObject.addInsertField("token_policy", "?");
  312.                 sqlQueryObject.addInsertField("api_key", "?");
  313.                 sqlQueryObject.addInsertField("api_key_header", "?");
  314.                 sqlQueryObject.addInsertField("app_id", "?");
  315.                 sqlQueryObject.addInsertField("app_id_header", "?");
  316.                 sqlQuery = sqlQueryObject.createSQLInsert();
  317.                 stm = connection.prepareStatement(sqlQuery);

  319.                 int index = 1;
  320.                 stm.setString(index++, endpointtype);
  321.                 stm.setString(index++, (isAbilitato ? url : null));
  322.                 stm.setString(index++, (isAbilitato ? transferMode : null));
  323.                 if(isAbilitato && transferModeChunkSize!=null){
  324.                     stm.setInt(index++, transferModeChunkSize);
  325.                 }
  326.                 else{
  327.                     stm.setNull(index++, Types.INTEGER);
  328.                 }
  329.                 stm.setString(index++, (isAbilitato ? redirectMode : null));
  330.                 if(isAbilitato && redirectMaxHop!=null){
  331.                     stm.setInt(index++, redirectMaxHop);
  332.                 }
  333.                 else{
  334.                     stm.setNull(index++, Types.INTEGER);
  335.                 }
  336.                 stm.setString(index++, isAbilitato ? nome : null);
  337.                 stm.setString(index++, isAbilitato ? tipo : null);
  338.                 stm.setString(index++, (isAbilitato ? utente : null));
  339.                 
  340.                 String plainPassword = isAbilitato ? password : null;
  341.                 String encPassword = null;
  342.                 if(isAbilitato && driverBYOK!=null && plainPassword!=null) {
  343.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainPassword);
  344.                     if(byokValue!=null) {
  345.                         encPassword = byokValue.getWrappedValue();
  346.                         plainPassword = byokValue.getWrappedPlainValue();
  347.                     }
  348.                 }
  349.                 stm.setString(index++, plainPassword);
  350.                 stm.setString(index++, encPassword);
  351.                 
  352.                 stm.setString(index++, (isAbilitato ? initcont : null));
  353.                 stm.setString(index++, (isAbilitato ? urlpkg : null));
  354.                 stm.setString(index++, (isAbilitato ? provurl : null));
  355.                 stm.setString(index++, (isAbilitato ? connectionfactory : null));
  356.                 stm.setString(index++, (isAbilitato ? sendas : null));
  357.                 stm.setString(index++, nomeConnettore);
  358.                 if(debug){
  359.                     stm.setInt(index++, 1);
  360.                 }else{
  361.                     stm.setInt(index++, 0);
  362.                 }
  363.                 if(proxy){
  364.                     stm.setInt(index++, 1);
  365.                 }else{
  366.                     stm.setInt(index++, 0);
  367.                 }
  368.                 stm.setString(index++, isAbilitato && proxy ? proxyType : null);
  369.                 stm.setString(index++, isAbilitato && proxy ? proxyHostname : null);
  370.                 stm.setString(index++, isAbilitato && proxy ? proxyPort : null);
  371.                 stm.setString(index++, isAbilitato && proxy ? proxyUsername : null);

  373.                 String plainProxyPassword = isAbilitato ? proxyPassword : null;
  374.                 String encProxyPassword = null;
  375.                 if(isAbilitato && driverBYOK!=null && plainProxyPassword!=null) {
  376.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainProxyPassword);
  377.                     if(byokValue!=null) {
  378.                         encProxyPassword = byokValue.getWrappedValue();
  379.                         plainProxyPassword = byokValue.getWrappedPlainValue();
  380.                     }
  381.                 }
  382.                 stm.setString(index++, plainProxyPassword);
  383.                 stm.setString(index++, encProxyPassword);
  384.                 
  385.                 if(tempiRispostaConnectionTimeout!=null) {
  386.                     stm.setInt(index++, tempiRispostaConnectionTimeout);
  387.                 }
  388.                 else {
  389.                     stm.setNull(index++, Types.INTEGER);
  390.                 }
  391.                 if(tempiRispostaReadTimeout!=null) {
  392.                     stm.setInt(index++, tempiRispostaReadTimeout);
  393.                 }
  394.                 else {
  395.                     stm.setNull(index++, Types.INTEGER);
  396.                 }
  397.                 if(tempiRispostaAvgResponseTime!=null) {
  398.                     stm.setInt(index++, tempiRispostaAvgResponseTime);
  399.                 }
  400.                 else {
  401.                     stm.setNull(index++, Types.INTEGER);
  402.                 }
  403.                 if(connettore.getCustom()!=null && connettore.getCustom()){
  404.                     stm.setInt(index++, 1);
  405.                 }else{
  406.                     stm.setInt(index++, 0);
  407.                 }
  408.                 stm.setString(index++, tokenPolicy);
  409.                 
  410.                 String apiKeyInsert = isAbilitato ? apiKey : null;
  411.                 if(isAbilitato && apiKey!=null && StringUtils.isNotEmpty(apiKey) && driverBYOK!=null && CostantiConnettori.isConfidential(CostantiDB.CONNETTORE_APIKEY)) {
  412.                     BYOKWrappedValue byokValue = driverBYOK.wrap(apiKey);
  413.                     if(byokValue!=null) {
  414.                         apiKeyInsert = byokValue.getWrappedValue();
  415.                         stm.setString(index++, byokValue.getWrappedValue());
  416.                     }
  417.                     else {
  418.                         stm.setString(index++, apiKey);
  419.                     }
  420.                 }
  421.                 else {
  422.                     stm.setString(index++, apiKey);
  423.                 }
  424.                 stm.setString(index++, isAbilitato ? apiKeyHeader : null);
  425.                 stm.setString(index++, isAbilitato ? appId : null);
  426.                 stm.setString(index++, isAbilitato ? appIdHeader : null);

  428.                 DriverConfigurazioneDBLib.logDebug("CRUDConnettore CREATE : \n" + DBUtils.formatSQLString(sqlQuery, endpointtype, url, 
  429.                         transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  430.                         nome, tipo, utente, plainPassword, encPassword, 
  431.                         initcont, urlpkg, provurl, connectionfactory, sendas, nomeConnettore,debug,
  432.                         proxy, proxyType, proxyHostname, proxyPort, proxyUsername, plainProxyPassword, encProxyPassword,
  433.                         tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaAvgResponseTime,
  434.                         (connettore.getCustom()!=null && connettore.getCustom()),
  435.                         tokenPolicy,
  436.                         apiKeyInsert, apiKeyHeader, appId, appIdHeader));

  438.                 n = stm.executeUpdate();
  439.                 stm.close();
  440.                 DriverConfigurazioneDBLib.logDebug("Inserted " + n + " row(s)");


  443.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  444.                 sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  445.                 sqlQueryObject.addSelectField("*");
  446.                 sqlQueryObject.addWhereCondition("endpointtype = ?");
  447.                 sqlQueryObject.addWhereCondition("nome_connettore = ?");
  448.                 sqlQueryObject.setANDLogicOperator(true);
  449.                 sqlQuery = sqlQueryObject.createSQLQuery();
  450.                 stm = connection.prepareStatement(sqlQuery);

  452.                 stm.setString(1, endpointtype);
  453.                 stm.setString(2, nomeConnettore);

  455.                 DriverConfigurazioneDBLib.logDebug("Recupero idConnettore inserito : \n" + DBUtils.formatSQLString(sqlQuery, endpointtype, nomeConnettore));

  457.                 rs = stm.executeQuery();

  459.                 if (rs.next()) {
  460.                     idConnettore = rs.getLong("id");
  461.                     connettore.setId(idConnettore);
  462.                 } else {
  463.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConnettore] Errore tentanto di effettuare la select dopo una create, non riesco a recuperare l'id!");
  464.                 }

  466.                 rs.close();
  467.                 stm.close();                
  468.                 
  469.                 // Custom properties
  470.                 if(connettore.getCustom()!=null && connettore.getCustom()){                 
  471.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  472.                     sqlQueryObject.addInsertTable(CostantiDB.CONNETTORI_CUSTOM);
  473.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME, "?");
  474.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE, "?");
  475.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE, "?");
  476.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ID_CONNETTORE, "?");
  477.                     sqlQuery = sqlQueryObject.createSQLInsert();
  478.                     
  479.                     for (int i = 0; i < connettore.sizePropertyList(); i++) {
  480.                         nomeProperty = connettore.getProperty(i).getNome();
  481.                         if(propertiesGestiteAttraversoColonneAdHoc.contains(nomeProperty)){
  482.                             continue;
  483.                         }
  484.                         valoreProperty = connettore.getProperty(i).getValore();
  485.                         if (valoreProperty != null && valoreProperty.equals(""))
  486.                             valoreProperty = null;
  487.                     
  488.                         if(valoreProperty==null){
  489.                             throw new DriverConfigurazioneException("Property ["+nomeProperty+"] without value");
  490.                         }
  491.                         
  492.                         String plainValue = valoreProperty;
  493.                         String encValue = null;
  494.                         if(driverBYOK!=null && CostantiConnettori.isConfidential(nomeProperty)) {
  495.                             BYOKWrappedValue byokValue = driverBYOK.wrap(valoreProperty);
  496.                             if(byokValue!=null) {
  497.                                 encValue = byokValue.getWrappedValue();
  498.                                 plainValue = byokValue.getWrappedPlainValue();
  499.                             }
  500.                         }
  501.                         
  502.                         stm = connection.prepareStatement(sqlQuery);
  503.                         stm.setString(1, nomeProperty);
  504.                         stm.setString(2, plainValue);
  505.                         stm.setString(3, encValue);
  506.                         stm.setLong(4, connettore.getId());
  507.                         stm.executeUpdate();
  508.                         stm.close();
  509.                     }               
  510.                 }
  511.                 else if(extendedProperties.size()>0){
  512.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  513.                     sqlQueryObject.addInsertTable(CostantiDB.CONNETTORI_CUSTOM);
  514.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME, "?");
  515.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE, "?");
  516.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE, "?");
  517.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ID_CONNETTORE, "?");
  518.                     sqlQuery = sqlQueryObject.createSQLInsert();
  519.                     
  520.                     for (String nomeP : extendedProperties.keySet()) {
  521.                         valoreProperty = extendedProperties.get(nomeP);
  522.                         if (valoreProperty != null && valoreProperty.equals(""))
  523.                             valoreProperty = null;
  524.                     
  525.                         if(valoreProperty==null){
  526.                             throw new DriverConfigurazioneException("Property ["+nomeP+"] without value");
  527.                         }
  528.                         
  529.                         String plainValue = valoreProperty;
  530.                         String encValue = null;
  531.                         if(driverBYOK!=null && CostantiConnettori.isConfidential(nomeProperty)) {
  532.                             BYOKWrappedValue byokValue = driverBYOK.wrap(valoreProperty);
  533.                             if(byokValue!=null) {
  534.                                 encValue = byokValue.getWrappedValue();
  535.                                 plainValue = byokValue.getWrappedPlainValue();
  536.                             }
  537.                         }
  538.                         
  539.                         stm = connection.prepareStatement(sqlQuery);
  540.                         stm.setString(1, nomeP);
  541.                         stm.setString(2, plainValue);
  542.                         stm.setString(3, encValue);
  543.                         stm.setLong(4, connettore.getId());
  544.                         stm.executeUpdate();
  545.                         stm.close();
  546.                     }               
  547.                 }

  549.                 break;

  551.             case UPDATE:
  552.                 // update
  553.                 idConnettore = connettore.getId();

  555.                 if (idConnettore < 0)
  556.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConnettore] L'id del connettore non puo essere 0 tentando di fare una operazione di update.");

  558.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  559.                 sqlQueryObject.addUpdateTable(CostantiDB.CONNETTORI);
  560.                 sqlQueryObject.addUpdateField(CostantiDB.CONNETTORI_COLUMN_ENDPOINT_TYPE, "?");
  561.                 sqlQueryObject.addUpdateField("url", "?");
  562.                 sqlQueryObject.addUpdateField("transfer_mode", "?");
  563.                 sqlQueryObject.addUpdateField("transfer_mode_chunk_size", "?");
  564.                 sqlQueryObject.addUpdateField("redirect_mode", "?");
  565.                 sqlQueryObject.addUpdateField("redirect_max_hop", "?");
  566.                 sqlQueryObject.addUpdateField("nome", "?");
  567.                 sqlQueryObject.addUpdateField("tipo", "?");
  568.                 sqlQueryObject.addUpdateField("utente", "?");
  569.                 sqlQueryObject.addUpdateField("password", "?");
  570.                 sqlQueryObject.addUpdateField("enc_password", "?");
  571.                 sqlQueryObject.addUpdateField("initcont", "?");
  572.                 sqlQueryObject.addUpdateField("urlpkg", "?");
  573.                 sqlQueryObject.addUpdateField("provurl", "?");
  574.                 sqlQueryObject.addUpdateField("connection_factory", "?");
  575.                 sqlQueryObject.addUpdateField("send_as", "?");
  576.                 sqlQueryObject.addUpdateField(CostantiDB.CONNETTORI_COLUMN_NOME, "?");
  577.                 sqlQueryObject.addUpdateField("debug", "?");
  578.                 sqlQueryObject.addUpdateField("proxy", "?");        
  579.                 sqlQueryObject.addUpdateField("proxy_type", "?");       
  580.                 sqlQueryObject.addUpdateField("proxy_hostname", "?");       
  581.                 sqlQueryObject.addUpdateField("proxy_port", "?");       
  582.                 sqlQueryObject.addUpdateField("proxy_username", "?");       
  583.                 sqlQueryObject.addUpdateField("proxy_password", "?");
  584.                 sqlQueryObject.addUpdateField("enc_proxy_password", "?");
  585.                 sqlQueryObject.addUpdateField("connection_timeout", "?");       
  586.                 sqlQueryObject.addUpdateField("read_timeout", "?");     
  587.                 sqlQueryObject.addUpdateField("avg_response_time", "?");
  588.                 sqlQueryObject.addUpdateField("custom", "?");
  589.                 sqlQueryObject.addUpdateField("token_policy", "?");
  590.                 sqlQueryObject.addUpdateField("api_key", "?");
  591.                 sqlQueryObject.addUpdateField("api_key_header", "?");
  592.                 sqlQueryObject.addUpdateField("app_id", "?");
  593.                 sqlQueryObject.addUpdateField("app_id_header", "?");
  594.                 sqlQueryObject.addWhereCondition("id=?");
  595.                 sqlQuery = sqlQueryObject.createSQLUpdate();
  596.                 stm = connection.prepareStatement(sqlQuery);

  598.                 index = 1;
  599.                 stm.setString(index++, endpointtype);
  600.                 stm.setString(index++, url);
  601.                 stm.setString(index++, (isAbilitato ? transferMode : null));
  602.                 if(isAbilitato && transferModeChunkSize!=null){
  603.                     stm.setInt(index++, transferModeChunkSize);
  604.                 }
  605.                 else{
  606.                     stm.setNull(index++, Types.INTEGER);
  607.                 }
  608.                 stm.setString(index++, (isAbilitato ? redirectMode : null));
  609.                 if(isAbilitato && redirectMaxHop!=null){
  610.                     stm.setInt(index++, redirectMaxHop);
  611.                 }
  612.                 else{
  613.                     stm.setNull(index++, Types.INTEGER);
  614.                 }
  615.                 stm.setString(index++, isAbilitato ? nome : null);
  616.                 stm.setString(index++, isAbilitato ? tipo: null);
  617.                 stm.setString(index++, (isAbilitato ? utente : null));
  618.                 
  619.                 plainPassword = isAbilitato ? password : null;
  620.                 encPassword = null;
  621.                 if(isAbilitato && driverBYOK!=null && plainPassword!=null) {
  622.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainPassword);
  623.                     if(byokValue!=null) {
  624.                         encPassword = byokValue.getWrappedValue();
  625.                         plainPassword = byokValue.getWrappedPlainValue();
  626.                     }
  627.                 }
  628.                 stm.setString(index++, plainPassword);
  629.                 stm.setString(index++, encPassword);
  630.                 
  631.                 stm.setString(index++, (isAbilitato ? initcont : null));
  632.                 stm.setString(index++, (isAbilitato ? urlpkg : null));
  633.                 stm.setString(index++, (isAbilitato ? provurl : null));
  634.                 stm.setString(index++, (isAbilitato ? connectionfactory : null));
  635.                 stm.setString(index++, (isAbilitato ? sendas : null));
  636.                 stm.setString(index++, nomeConnettore);
  637.                 if(debug){
  638.                     stm.setInt(index++, 1);
  639.                 }else{
  640.                     stm.setInt(index++, 0);
  641.                 }
  642.                 if(proxy){
  643.                     stm.setInt(index++, 1);
  644.                 }else{
  645.                     stm.setInt(index++, 0);
  646.                 }
  647.                 stm.setString(index++, isAbilitato && proxy ? proxyType : null);
  648.                 stm.setString(index++, isAbilitato && proxy ? proxyHostname : null);
  649.                 stm.setString(index++, isAbilitato && proxy ? proxyPort : null);
  650.                 stm.setString(index++, isAbilitato && proxy ? proxyUsername : null);

  652.                 plainProxyPassword = isAbilitato ? proxyPassword : null;
  653.                 encProxyPassword = null;
  654.                 if(isAbilitato && driverBYOK!=null && plainProxyPassword!=null) {
  655.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainProxyPassword);
  656.                     if(byokValue!=null) {
  657.                         encProxyPassword = byokValue.getWrappedValue();
  658.                         plainProxyPassword = byokValue.getWrappedPlainValue();
  659.                     }
  660.                 }
  661.                 stm.setString(index++, plainProxyPassword);
  662.                 stm.setString(index++, encProxyPassword);
  663.                 
  664.                 if(tempiRispostaConnectionTimeout!=null) {
  665.                     stm.setInt(index++, tempiRispostaConnectionTimeout);
  666.                 }
  667.                 else {
  668.                     stm.setNull(index++, Types.INTEGER);
  669.                 }
  670.                 if(tempiRispostaReadTimeout!=null) {
  671.                     stm.setInt(index++, tempiRispostaReadTimeout);
  672.                 }
  673.                 else {
  674.                     stm.setNull(index++, Types.INTEGER);
  675.                 }
  676.                 if(tempiRispostaAvgResponseTime!=null) {
  677.                     stm.setInt(index++, tempiRispostaAvgResponseTime);
  678.                 }
  679.                 else {
  680.                     stm.setNull(index++, Types.INTEGER);
  681.                 }
  682.                 if(connettore.getCustom()!=null && connettore.getCustom()){
  683.                     stm.setInt(index++, 1);
  684.                 }else{
  685.                     stm.setInt(index++, 0);
  686.                 }
  687.                 stm.setString(index++, tokenPolicy);
  688.                 
  689.                 apiKeyInsert = isAbilitato ? apiKey : null;
  690.                 if(isAbilitato && apiKey!=null && StringUtils.isNotEmpty(apiKey) && driverBYOK!=null && CostantiConnettori.isConfidential(CostantiDB.CONNETTORE_APIKEY)) {
  691.                     BYOKWrappedValue byokValue = driverBYOK.wrap(apiKey);
  692.                     if(byokValue!=null) {
  693.                         apiKeyInsert = byokValue.getWrappedValue();
  694.                         stm.setString(index++, byokValue.getWrappedValue());
  695.                     }
  696.                     else {
  697.                         stm.setString(index++, apiKey);
  698.                     }
  699.                 }
  700.                 else {
  701.                     stm.setString(index++, apiKey);
  702.                 }
  703.                 stm.setString(index++, isAbilitato ? apiKeyHeader : null);
  704.                 stm.setString(index++, isAbilitato ? appId : null);
  705.                 stm.setString(index++, isAbilitato ? appIdHeader : null);
  706.                 
  707.                 stm.setLong(index++, idConnettore);

  709.                 stm.executeUpdate();
  710.                 stm.close();
  711.                 DriverConfigurazioneDBLib.logDebug("CRUDConnettore UPDATE : \n" + DBUtils.formatSQLString(sqlQuery, endpointtype, url, 
  712.                         transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  713.                         nome, tipo, utente, plainPassword, encPassword, 
  714.                         initcont, urlpkg, provurl, connectionfactory, sendas,nomeConnettore, debug,
  715.                         proxy, proxyType, proxyHostname, proxyPort, proxyUsername, plainProxyPassword, encProxyPassword,
  716.                         tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaAvgResponseTime,
  717.                         (connettore.getCustom()!=null && connettore.getCustom()),
  718.                         tokenPolicy,
  719.                         apiKeyInsert, apiKeyHeader, appId, appIdHeader,
  720.                         idConnettore));

  722.                 // Custom properties
  723.                 // Delete eventuali vecchie properties
  724.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  725.                 sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI_CUSTOM);
  726.                 sqlQueryObject.addWhereCondition("id_connettore=?");
  727.                 sqlQuery = sqlQueryObject.createSQLDelete();
  728.                 stm = connection.prepareStatement(sqlQuery);
  729.                 stm.setLong(1, idConnettore);
  730.                 stm.executeUpdate();
  731.                 stm.close();
  732.                 // Aggiungo attuali
  733.                 if(connettore.getCustom()!=null && connettore.getCustom()){                 
  734.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  735.                     sqlQueryObject.addInsertTable(CostantiDB.CONNETTORI_CUSTOM);
  736.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME, "?");
  737.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE, "?");
  738.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE, "?");
  739.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ID_CONNETTORE, "?");
  740.                     sqlQuery = sqlQueryObject.createSQLInsert();
  741.                     
  742.                     for (int i = 0; i < connettore.sizePropertyList(); i++) {
  743.                         nomeProperty = connettore.getProperty(i).getNome();
  744.                         if(propertiesGestiteAttraversoColonneAdHoc.contains(nomeProperty)){
  745.                             continue;
  746.                         }
  747.                         valoreProperty = connettore.getProperty(i).getValore();
  748.                         if (valoreProperty != null && valoreProperty.equals(""))
  749.                             valoreProperty = null;
  750.                     
  751.                         if(valoreProperty==null){
  752.                             throw new DriverConfigurazioneException("Property ["+nomeProperty+"] without value");
  753.                         }
  754.                         
  755.                         String plainValue = valoreProperty;
  756.                         String encValue = null;
  757.                         if(driverBYOK!=null && CostantiConnettori.isConfidential(nomeProperty)) {
  758.                             BYOKWrappedValue byokValue = driverBYOK.wrap(valoreProperty);
  759.                             if(byokValue!=null) {
  760.                                 encValue = byokValue.getWrappedValue();
  761.                                 plainValue = byokValue.getWrappedPlainValue();
  762.                             }
  763.                         }
  764.                         
  765.                         stm = connection.prepareStatement(sqlQuery);
  766.                         stm.setString(1, nomeProperty);
  767.                         stm.setString(2, plainValue);
  768.                         stm.setString(3, encValue);
  769.                         stm.setLong(4, idConnettore);
  770.                         stm.executeUpdate();
  771.                         stm.close();
  772.                     }               
  773.                 }
  774.                 else if(extendedProperties.size()>0){
  775.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  776.                     sqlQueryObject.addInsertTable(CostantiDB.CONNETTORI_CUSTOM);
  777.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME, "?");
  778.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE, "?");
  779.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE, "?");
  780.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ID_CONNETTORE, "?");
  781.                     sqlQuery = sqlQueryObject.createSQLInsert();
  782.                     
  783.                     for (String nomeP : extendedProperties.keySet()) {
  784.                         valoreProperty = extendedProperties.get(nomeP);
  785.                         if (valoreProperty != null && valoreProperty.equals(""))
  786.                             valoreProperty = null;
  787.                     
  788.                         if(valoreProperty==null){
  789.                             throw new DriverConfigurazioneException("Property ["+nomeP+"] without value");
  790.                         }
  791.                         
  792.                         String plainValue = valoreProperty;
  793.                         String encValue = null;
  794.                         if(driverBYOK!=null && CostantiConnettori.isConfidential(nomeProperty)) {
  795.                             BYOKWrappedValue byokValue = driverBYOK.wrap(valoreProperty);
  796.                             if(byokValue!=null) {
  797.                                 encValue = byokValue.getWrappedValue();
  798.                                 plainValue = byokValue.getWrappedPlainValue();
  799.                             }
  800.                         }
  801.                         
  802.                         stm = connection.prepareStatement(sqlQuery);
  803.                         stm.setString(1, nomeP);
  804.                         stm.setString(2, plainValue);
  805.                         stm.setString(3, encValue);
  806.                         stm.setLong(4, idConnettore);
  807.                         stm.executeUpdate();
  808.                         stm.close();
  809.                     }           
  810.                 }
  811.                 
  812.                 break;

  814.             case DELETE:
  815.                 // delete
  816.                 idConnettore = connettore.getId();

  818.                 if (idConnettore < 0)
  819.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConnettore] L'id del connettore non puo essere 0 tentando di fare una operazione di delete.");

  821.                 // Delete eventuali vecchie properties
  822.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  823.                 sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI_CUSTOM);
  824.                 sqlQueryObject.addWhereCondition("id_connettore=?");
  825.                 sqlQuery = sqlQueryObject.createSQLDelete();
  826.                 stm = connection.prepareStatement(sqlQuery);
  827.                 stm.setLong(1, idConnettore);
  828.                 stm.executeUpdate();
  829.                 stm.close();
  830.                 
  831.                 // Delete connettori
  832.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  833.                 sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI);
  834.                 sqlQueryObject.addWhereCondition("id=?");
  835.                 sqlQuery = sqlQueryObject.createSQLDelete();
  836.                 stm = connection.prepareStatement(sqlQuery);
  837.                 stm.setLong(1, idConnettore);
  838.                 stm.executeUpdate();
  839.                 stm.close();
  840.                 DriverConfigurazioneDBLib.logDebug("CRUDConnettore DELETE : \n" + DBUtils.formatSQLString(sqlQuery, idConnettore));

  842.                 break;
  843.             }

  845.             // ritorno l id del connettore questo e' utile in caso di create
  846.             return idConnettore;

  848.         } catch (SQLException se) {
  849.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConnettore] SQLException : " + se.getMessage(),se);
  850.         }catch (Exception se) {
  851.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDConnettore] Exception : " + se.getMessage(),se);
  852.         } finally {
  853.             JDBCUtilities.closeResources(rs, stm);
  854.         }
  855.     }

  857.     /**
  858.      * Ritorna il connettore con idConnettore, null se il connettore non esiste
  859.      */
  860.     protected static Connettore getConnettore(long idConnettore, Connection connection, IDriverBYOK driverBYOK) throws DriverConfigurazioneException {

  862.         Connettore connettore = null;

  864.         PreparedStatement stm = null;
  865.         ResultSet rs = null;

  867.         try {
  868.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  869.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  870.             sqlQueryObject.addSelectField("*");
  871.             sqlQueryObject.addWhereCondition("id = ?");
  872.             String sqlQuery = sqlQueryObject.createSQLQuery();

  874.             stm = connection.prepareStatement(sqlQuery);
  875.             stm.setLong(1, idConnettore);

  877.             DriverConfigurazioneDBLib.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idConnettore));

  879.             rs = stm.executeQuery();

  881.             if (rs.next()) {
  882.                 String endpoint = rs.getString(CostantiDB.CONNETTORI_COLUMN_ENDPOINT_TYPE);
  883.                 if (endpoint == null || endpoint.equals("") || endpoint.equals(TipiConnettore.DISABILITATO.getNome())) {
  884.                     connettore = new Connettore();
  885.                     connettore.setNome(rs.getString(CostantiDB.CONNETTORI_COLUMN_NOME));
  886.                     connettore.setTipo(TipiConnettore.DISABILITATO.getNome());
  887.                     connettore.setId(idConnettore);

  889.                 } else {
  890.                     Property prop = null;
  891.                     connettore = new Connettore();
  892.                     connettore.setNome(rs.getString(CostantiDB.CONNETTORI_COLUMN_NOME));
  893.                     connettore.setTipo(endpoint);
  894.                     // l'id del connettore e' quello passato come parametro
  895.                     connettore.setId(idConnettore);

  897.                     // Debug
  898.                     if(rs.getInt("debug")==1){
  899.                         prop = new Property();
  900.                         prop.setNome(CostantiDB.CONNETTORE_DEBUG);
  901.                         prop.setValore("true");
  902.                         connettore.addProperty(prop);
  903.                     }
  904.                     
  905.                     // Proxy
  906.                     readConnettoreProxy(rs, connettore, driverBYOK);
  907.                     
  908.                     // Tempi Risposta
  909.                     readConnettoreTempiRisposta(rs, connettore);
  910.                     
  911.                     // transfer_mode
  912.                     readConnettoreTransferMode(rs, connettore);
  913.                     
  914.                     // redirect_mode
  915.                     readConnettoreRedirectMode(rs, connettore);                 
  916.                     
  917.                     // token policy
  918.                     String tokenPolicy = rs.getString("token_policy");
  919.                     if(tokenPolicy!=null && !"".equals(tokenPolicy)){
  920.                         prop = new Property();
  921.                         prop.setNome(CostantiDB.CONNETTORE_TOKEN_POLICY);
  922.                         prop.setValore(tokenPolicy.trim());
  923.                         connettore.addProperty(prop);
  924.                     }

  926.                     // api key
  927.                     readAutenticazioneApiKey(rs, connettore, driverBYOK);

  929.                     if (endpoint.equals(CostantiDB.CONNETTORE_TIPO_HTTP)) {
  930.                         readConnettoreHttp(rs, connettore);
  931.                     } else if (endpoint.equals(TipiConnettore.JMS.getNome())){//jms
  932.                         readConnettoreJms(rs, connettore, driverBYOK);
  933.                     }else if(endpoint.equals(TipiConnettore.NULL.getNome())){
  934.                         //nessuna proprieta per connettore null
  935.                     }else if(endpoint.equals(TipiConnettore.NULLECHO.getNome())){
  936.                         //nessuna proprieta per connettore nullEcho
  937.                     }else if (!endpoint.equals(TipiConnettore.DISABILITATO.getNome())) {
  938.                         if(rs.getLong("custom")==1){
  939.                             // connettore custom
  940.                             readPropertiesConnettoreCustom(idConnettore,connettore,connection,driverBYOK);
  941.                             connettore.setCustom(true);
  942.                         }
  943.                         else{
  944.                             // legge da file properties
  945.                             connettore.setPropertyList(ConnettorePropertiesUtilities.getPropertiesConnettore(endpoint,connection,DriverConfigurazioneDBLib.tipoDB));
  946.                         }
  947.                     }

  949.                 }
  950.             }
  951.             
  952.             // Extended Info
  953.             readPropertiesConnettoreExtendedInfo(idConnettore,connettore,connection,driverBYOK);
  954.             
  955.             return connettore;
  956.         } catch (SQLException sqle) {

  958.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::getConnettore] SQLException : " + sqle.getMessage(),sqle);
  959.         }catch (DriverConfigurazioneException e) {
  960.             throw e;
  961.         }catch (Exception sqle) {

  963.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::getConnettore] Exception : " + sqle.getMessage(),sqle);
  964.         } finally {
  965.             //Chiudo statement and resultset
  966.             JDBCUtilities.closeResources(rs, stm);
  967.         }
  968.     }
  969.     
  970.     private static void readConnettoreProxy(ResultSet rs, Connettore connettore, IDriverBYOK driverBYOK) throws SQLException, UtilsException {
  971.         if(rs.getInt("proxy")==1){
  972.             
  973.             String tmp = rs.getString("proxy_type");
  974.             if(tmp!=null && !"".equals(tmp)){
  975.                 Property prop = new Property();
  976.                 prop.setNome(CostantiDB.CONNETTORE_PROXY_TYPE);
  977.                 prop.setValore(tmp.trim());
  978.                 connettore.addProperty(prop);
  979.             }
  980.             
  981.             tmp = rs.getString("proxy_hostname");
  982.             if(tmp!=null && !"".equals(tmp)){
  983.                 Property prop = new Property();
  984.                 prop.setNome(CostantiDB.CONNETTORE_PROXY_HOSTNAME);
  985.                 prop.setValore(tmp.trim());
  986.                 connettore.addProperty(prop);
  987.             }
  988.             
  989.             tmp = rs.getString("proxy_port");
  990.             if(tmp!=null && !"".equals(tmp)){
  991.                 Property prop = new Property();
  992.                 prop.setNome(CostantiDB.CONNETTORE_PROXY_PORT);
  993.                 prop.setValore(tmp.trim());
  994.                 connettore.addProperty(prop);
  995.             }
  996.             
  997.             readConnettoreProxyCredentials(rs, connettore, driverBYOK);
  998.         }
  999.     }
  1000.     private static void readConnettoreProxyCredentials(ResultSet rs, Connettore connettore, IDriverBYOK driverBYOK) throws SQLException, UtilsException {
  1001.         String tmp = rs.getString("proxy_username");
  1002.         if(tmp!=null && !"".equals(tmp)){
  1003.             Property prop = new Property();
  1004.             prop.setNome(CostantiDB.CONNETTORE_PROXY_USERNAME);
  1005.             prop.setValore(tmp.trim());
  1006.             connettore.addProperty(prop);
  1007.         }
  1008.         
  1009.         tmp = rs.getString("proxy_password");
  1010.         String encValue = rs.getString("enc_proxy_password");
  1011.         if(tmp!=null && !"".equals(tmp)){
  1012.             Property prop = new Property();
  1013.             prop.setNome(CostantiDB.CONNETTORE_PROXY_PASSWORD);
  1014.             
  1015.             if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1016.                 if(driverBYOK!=null) {
  1017.                     prop.setValore(driverBYOK.unwrapAsString(encValue));
  1018.                 }
  1019.                 else {
  1020.                     prop.setValore(encValue);
  1021.                 }
  1022.             }
  1023.             else {
  1024.                 prop.setValore(tmp.trim());
  1025.             }
  1026.             
  1027.             connettore.addProperty(prop);
  1028.         }
  1029.     }
  1030.     
  1031.     private static void readConnettoreTempiRisposta(ResultSet rs, Connettore connettore) throws SQLException {
  1032.         int connectionTimeout = rs.getInt("connection_timeout");
  1033.         if(connectionTimeout>0){
  1034.             Property prop = new Property();
  1035.             prop.setNome(CostantiDB.CONNETTORE_CONNECTION_TIMEOUT);
  1036.             prop.setValore(connectionTimeout+"");
  1037.             connettore.addProperty(prop);
  1038.         }
  1039.         int readTimeout = rs.getInt("read_timeout");
  1040.         if(readTimeout>0){
  1041.             Property prop = new Property();
  1042.             prop.setNome(CostantiDB.CONNETTORE_READ_CONNECTION_TIMEOUT);
  1043.             prop.setValore(readTimeout+"");
  1044.             connettore.addProperty(prop);
  1045.         }
  1046.         int avgResponseTime = rs.getInt("avg_response_time");
  1047.         if(avgResponseTime>0){
  1048.             Property prop = new Property();
  1049.             prop.setNome(CostantiDB.CONNETTORE_TEMPO_MEDIO_RISPOSTA);
  1050.             prop.setValore(avgResponseTime+"");
  1051.             connettore.addProperty(prop);
  1052.         }
  1053.     }
  1054.     
  1055.     private static void readConnettoreTransferMode(ResultSet rs, Connettore connettore) throws SQLException {
  1056.         String transferMode = rs.getString("transfer_mode");
  1057.         if(transferMode!=null && !"".equals(transferMode)){
  1058.             
  1059.             Property prop = new Property();
  1060.             prop.setNome(CostantiDB.CONNETTORE_HTTP_DATA_TRANSFER_MODE);
  1061.             prop.setValore(transferMode.trim());
  1062.             connettore.addProperty(prop);
  1063.             
  1064.             transferMode = rs.getString("transfer_mode_chunk_size");
  1065.             if(transferMode!=null && !"".equals(transferMode)){
  1066.                 prop = new Property();
  1067.                 prop.setNome(CostantiDB.CONNETTORE_HTTP_DATA_TRANSFER_MODE_CHUNK_SIZE);
  1068.                 prop.setValore(transferMode.trim());
  1069.                 connettore.addProperty(prop);
  1070.             }
  1071.         }
  1072.     }
  1073.     
  1074.     private static void readConnettoreRedirectMode(ResultSet rs, Connettore connettore) throws SQLException {
  1075.         String redirectMode = rs.getString("redirect_mode");
  1076.         if(redirectMode!=null && !"".equals(redirectMode)){
  1077.             
  1078.             Property prop = new Property();
  1079.             prop.setNome(CostantiDB.CONNETTORE_HTTP_REDIRECT_FOLLOW);
  1080.             prop.setValore(redirectMode.trim());
  1081.             connettore.addProperty(prop);
  1082.             
  1083.             redirectMode = rs.getString("redirect_max_hop");
  1084.             if(redirectMode!=null && !"".equals(redirectMode)){
  1085.                 prop = new Property();
  1086.                 prop.setNome(CostantiDB.CONNETTORE_HTTP_REDIRECT_MAX_HOP);
  1087.                 prop.setValore(redirectMode.trim());
  1088.                 connettore.addProperty(prop);
  1089.             }
  1090.         }
  1091.     }
  1092.     
  1093.     private static void readAutenticazioneApiKey(ResultSet rs, Connettore connettore, IDriverBYOK driverBYOK) throws SQLException, UtilsException {
  1094.         String apiKey = rs.getString("api_key");
  1095.         if(apiKey!=null && !"".equals(apiKey)){
  1096.             
  1097.             Property prop = new Property();
  1098.             prop.setNome(CostantiDB.CONNETTORE_APIKEY);
  1099.             if(driverBYOK!=null) {
  1100.                 prop.setValore(driverBYOK.unwrapAsString(apiKey));
  1101.             }
  1102.             else {
  1103.                 prop.setValore(apiKey);
  1104.             }
  1105.             connettore.addProperty(prop);
  1106.             
  1107.             String apiKeyHeader = rs.getString("api_key_header");
  1108.             if(apiKeyHeader!=null && !"".equals(apiKeyHeader)){
  1109.                 prop = new Property();
  1110.                 prop.setNome(CostantiDB.CONNETTORE_APIKEY_HEADER);
  1111.                 prop.setValore(apiKeyHeader.trim());
  1112.                 connettore.addProperty(prop);
  1113.             }
  1114.             
  1115.             
  1116.             String appId = rs.getString("app_id");
  1117.             if(appId!=null && !"".equals(appId)){
  1118.                 
  1119.                 prop = new Property();
  1120.                 prop.setNome(CostantiDB.CONNETTORE_APIKEY_APPID);
  1121.                 prop.setValore(appId);
  1122.                 connettore.addProperty(prop);
  1123.                 
  1124.                 String appIdHeader = rs.getString("app_id_header");
  1125.                 if(appIdHeader!=null && !"".equals(appIdHeader)){
  1126.                     prop = new Property();
  1127.                     prop.setNome(CostantiDB.CONNETTORE_APIKEY_APPID_HEADER);
  1128.                     prop.setValore(appIdHeader.trim());
  1129.                     connettore.addProperty(prop);
  1130.                 }
  1131.             }
  1132.         }
  1133.     }
  1134.     
  1135.     private static void readConnettoreHttp(ResultSet rs, Connettore connettore) throws DriverConfigurazioneException, SQLException {
  1136.         //  url
  1137.         String value = rs.getString("url");
  1138.         if(value!=null)
  1139.             value = value.trim();
  1140.         if(value == null || "".equals(value) || " ".equals(value)){
  1141.             throw new DriverConfigurazioneException("Connettore di tipo http possiede una url non definita");
  1142.         }
  1143.         Property prop = new Property();
  1144.         prop.setNome(CostantiDB.CONNETTORE_HTTP_LOCATION);
  1145.         prop.setValore(value);
  1146.         connettore.addProperty(prop);
  1147.     }
  1148.     
  1149.     private static void readConnettoreJms(ResultSet rs, Connettore connettore, IDriverBYOK driverBYOK) throws DriverConfigurazioneException, SQLException, UtilsException {
  1150.         // nome coda/topic
  1151.         String value = rs.getString("nome");
  1152.         if(value!=null)
  1153.             value = value.trim();
  1154.         if(value == null || "".equals(value) || " ".equals(value)){
  1155.             throw new DriverConfigurazioneException("Connettore di tipo jms possiede il nome della coda/topic non definito");
  1156.         }
  1157.         Property prop = new Property();
  1158.         prop.setNome(CostantiDB.CONNETTORE_JMS_NOME);
  1159.         prop.setValore(value);
  1160.         connettore.addProperty(prop);

  1162.         // tipo
  1163.         value = rs.getString("tipo");
  1164.         if(value!=null)
  1165.             value = value.trim();
  1166.         if(value == null || "".equals(value) || " ".equals(value)){
  1167.             throw new DriverConfigurazioneException("Connettore di tipo jms possiede il tipo della coda non definito");
  1168.         }
  1169.         prop = new Property();
  1170.         prop.setNome(CostantiDB.CONNETTORE_JMS_TIPO);
  1171.         prop.setValore(value);
  1172.         connettore.addProperty(prop);

  1174.         // connection-factory
  1175.         value = rs.getString("connection_factory");
  1176.         if(value!=null)
  1177.             value = value.trim();
  1178.         if(value == null || "".equals(value) || " ".equals(value)){
  1179.             throw new DriverConfigurazioneException("Connettore di tipo jms non possiede la definizione di una Connection Factory");
  1180.         }
  1181.         prop = new Property();
  1182.         prop.setNome(CostantiDB.CONNETTORE_JMS_CONNECTION_FACTORY);
  1183.         prop.setValore(value);
  1184.         connettore.addProperty(prop);

  1186.         // send_as
  1187.         value = rs.getString("send_as");
  1188.         if(value!=null)
  1189.             value = value.trim();
  1190.         if(value == null || "".equals(value) || " ".equals(value)){
  1191.             throw new DriverConfigurazioneException("Connettore di tipo jms possiede il tipo dell'oggetto JMS non definito");
  1192.         }
  1193.         prop = new Property();
  1194.         prop.setNome(CostantiDB.CONNETTORE_JMS_SEND_AS);
  1195.         prop.setValore(value);
  1196.         connettore.addProperty(prop);

  1198.         readConnettoreJmsCredentials(rs, connettore, driverBYOK);
  1199.         
  1200.         readConnettoreJmsContext(rs, connettore);
  1201.     }
  1202.     private static void readConnettoreJmsCredentials(ResultSet rs, Connettore connettore, IDriverBYOK driverBYOK) throws SQLException, UtilsException {
  1203.         // user
  1204.         String usr = rs.getString("utente");
  1205.         if (usr != null && !usr.trim().equals("")) {
  1206.             Property prop = new Property();
  1207.             prop.setNome(CostantiDB.CONNETTORE_USER);
  1208.             prop.setValore(usr);
  1209.             connettore.addProperty(prop);
  1210.         }
  1211.         // password
  1212.         String pwd = rs.getString("password");
  1213.         String encValue = rs.getString("enc_password");
  1214.         if (pwd != null && !pwd.trim().equals("")) {
  1215.             Property prop = new Property();
  1216.             prop.setNome(CostantiDB.CONNETTORE_PWD);
  1217.             
  1218.             if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1219.                 if(driverBYOK!=null) {
  1220.                     prop.setValore(driverBYOK.unwrapAsString(encValue));
  1221.                 }
  1222.                 else {
  1223.                     prop.setValore(encValue);
  1224.                 }
  1225.             }
  1226.             else {
  1227.                 prop.setValore(pwd);
  1228.             }
  1229.             
  1230.             connettore.addProperty(prop);
  1231.         }
  1232.     }
  1233.     private static void readConnettoreJmsContext(ResultSet rs, Connettore connettore) throws SQLException {
  1234.         // context-java.naming.factory.initial
  1235.         String initcont = rs.getString("initcont");
  1236.         if (initcont != null && !initcont.trim().equals("")) {
  1237.             Property prop = new Property();
  1238.             prop.setNome(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_FACTORY_INITIAL);
  1239.             prop.setValore(initcont);
  1240.             connettore.addProperty(prop);
  1241.         }
  1242.         // context-java.naming.factory.url.pkgs
  1243.         String urlpkg = rs.getString("urlpkg");
  1244.         if (urlpkg != null && !urlpkg.trim().equals("")) {
  1245.             Property prop = new Property();
  1246.             prop.setNome(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_FACTORY_URL_PKG);
  1247.             prop.setValore(urlpkg);
  1248.             connettore.addProperty(prop);
  1249.         }
  1250.         // context-java.naming.provider.url
  1251.         String provurl = rs.getString("provurl");
  1252.         if (provurl != null && !provurl.trim().equals("")) {
  1253.             Property prop = new Property();
  1254.             prop.setNome(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_PROVIDER_URL);
  1255.             prop.setValore(provurl);
  1256.             connettore.addProperty(prop);
  1257.         }
  1258.     }
  1259.     
  1260.     protected static void readPropertiesConnettoreCustom(long idConnettore, Connettore connettore, Connection connection,
  1261.             IDriverBYOK driverBYOK) throws DriverConfigurazioneException {

  1263.         PreparedStatement stm = null;
  1264.         ResultSet rs = null;

  1266.         try {
  1267.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1268.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI_CUSTOM);
  1269.             sqlQueryObject.addSelectField("*");
  1270.             sqlQueryObject.addWhereCondition("id_connettore = ?");
  1271.             String sqlQuery = sqlQueryObject.createSQLQuery();

  1273.             stm = connection.prepareStatement(sqlQuery);
  1274.             stm.setLong(1, idConnettore);

  1276.             DriverConfigurazioneDBLib.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idConnettore));

  1278.             rs = stm.executeQuery();
  1279.             
  1280.             while (rs.next()) {
  1281.                 processPropertiesConnettoreCustom(rs, connettore, driverBYOK);
  1282.             }
  1283.             
  1284.             rs.close();
  1285.             stm.close();

  1287.         } catch (SQLException sqle) {

  1289.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::readPropertiesConnettoreCustom] SQLException : " + sqle.getMessage(),sqle);
  1290.         }catch (Exception sqle) {

  1292.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::readPropertiesConnettoreCustom] Exception : " + sqle.getMessage(),sqle);
  1293.         } finally {
  1294.             //Chiudo statement and resultset
  1295.             JDBCUtilities.closeResources(rs, stm);
  1296.         }
  1297.     }
  1298.     private static void processPropertiesConnettoreCustom(ResultSet rs, Connettore connettore, 
  1299.             IDriverBYOK driverBYOK) throws SQLException, UtilsException {
  1300.         String nome = rs.getString(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME);
  1301.         String valore = rs.getString(CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE);
  1302.         String encValue = rs.getString(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE);
  1303.         
  1304.         if(CostantiDB.CONNETTORE_DEBUG.equals(nome)){ // lo posso aver aggiunto prima
  1305.             boolean found = false;
  1306.             for (int i = 0; i < connettore.sizePropertyList(); i++) {
  1307.                 if(CostantiDB.CONNETTORE_DEBUG.equals(connettore.getProperty(i).getNome())){
  1308.                     // already exists
  1309.                     found = true;
  1310.                     break;
  1311.                 }
  1312.             }
  1313.             if(found){
  1314.                 return; // è gia stato aggiunto.
  1315.             }
  1316.         }
  1317.         
  1318.         Property prop = new Property();
  1319.         prop.setNome(nome);
  1320.         if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1321.             if(driverBYOK!=null) {
  1322.                 prop.setValore(driverBYOK.unwrapAsString(encValue));
  1323.             }
  1324.             else {
  1325.                 prop.setValore(encValue);
  1326.             }
  1327.         }
  1328.         else {
  1329.             prop.setValore(valore);
  1330.         }
  1331.         connettore.addProperty(prop);
  1332.     }
  1333.     
  1334.     private static void readPropertiesConnettoreExtendedInfo(long idConnettore, Connettore connettore, Connection connection,
  1335.             IDriverBYOK driverBYOK) throws DriverConfigurazioneException {

  1337.         PreparedStatement stm = null;
  1338.         ResultSet rs = null;

  1340.         try {
  1341.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1342.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI_CUSTOM);
  1343.             sqlQueryObject.addSelectField("*");
  1344.             sqlQueryObject.addWhereCondition("id_connettore = ?");
  1345.             sqlQueryObject.addWhereLikeCondition(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME, CostantiConnettori.CONNETTORE_EXTENDED_PREFIX+"%");
  1346.             String sqlQuery = sqlQueryObject.createSQLQuery();

  1348.             stm = connection.prepareStatement(sqlQuery);
  1349.             stm.setLong(1, idConnettore);

  1351.             DriverConfigurazioneDBLib.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idConnettore));

  1353.             rs = stm.executeQuery();

  1355.             while (rs.next()) {
  1356.                 processPropertiesConnettoreExtendedInfo(rs, connettore, 
  1357.                         driverBYOK);
  1358.             }
  1359.             
  1360.             rs.close();
  1361.             stm.close();

  1363.         } catch (SQLException sqle) {

  1365.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::readPropertiesConnettoreExtendedInfo] SQLException : " + sqle.getMessage(),sqle);
  1366.         }catch (Exception sqle) {

  1368.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::readPropertiesConnettoreExtendedInfo] Exception : " + sqle.getMessage(),sqle);
  1369.         } finally {
  1370.             //Chiudo statement and resultset
  1371.             JDBCUtilities.closeResources(rs, stm);
  1372.         }
  1373.     }
  1374.     private static void processPropertiesConnettoreExtendedInfo(ResultSet rs, Connettore connettore, 
  1375.             IDriverBYOK driverBYOK) throws SQLException, UtilsException {
  1376.         String nome = rs.getString(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME);
  1377.         String valore = rs.getString(CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE);
  1378.         String encValue = rs.getString(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE);
  1379.         
  1380.         // Le proprietà sono già state inserite in caso di connettore custom
  1381.         boolean found = false;
  1382.         for (int i = 0; i < connettore.sizePropertyList(); i++) {
  1383.             if(nome.equals(connettore.getProperty(i).getNome())){
  1384.                 // already exists
  1385.                 found = true;
  1386.                 break;
  1387.             }
  1388.         }
  1389.         if(found){
  1390.             return; // è gia stato aggiunto.
  1391.         }
  1392.         
  1393.         Property prop = new Property();
  1394.         prop.setNome(nome);
  1395.         if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1396.             if(driverBYOK!=null) {
  1397.                 prop.setValore(driverBYOK.unwrapAsString(encValue));
  1398.             }
  1399.             else {
  1400.                 prop.setValore(encValue);
  1401.             }
  1402.         }
  1403.         else {
  1404.             prop.setValore(valore);
  1405.         }
  1406.         connettore.addProperty(prop);
  1407.     }

  1409.     /**
  1410.      * Se il connettore e' null lo considero disabilitato
  1411.      * @param connettore
  1412.      * @return true se il connettore e' abilitato
  1413.      */
  1414.     protected static boolean isConnettoreAbilitato(Connettore connettore) {

  1416.         //Se connettore null oppure il tipo e' null o "" o DISABILITATO allora connettore disabilitato
  1417.         //altrimenti e' abilitato.
  1418.         if (connettore == null)
  1419.             return false;

  1421.         String tipo = connettore.getTipo();
  1422.         return !TipiConnettore.DISABILITATO.getNome().equals(tipo);
  1423.     }

  1425.     protected static long getIdConnettoreSARISP(long idServizioApplicativo,Connection con) throws DriverConfigurazioneException
  1426.     {
  1427.         PreparedStatement stm = null;
  1428.         ResultSet rs = null;
  1429.         long idConnettore=-1;
  1430.         try
  1431.         {
  1432.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1433.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1434.             sqlQueryObject.addSelectField("*");
  1435.             sqlQueryObject.addWhereCondition("id = ?");
  1436.             String query = sqlQueryObject.createSQLQuery();
  1437.             stm=con.prepareStatement(query);
  1438.             stm.setLong(1, idServizioApplicativo);
  1439.             rs=stm.executeQuery();

  1441.             if(rs.next()){
  1442.                 idConnettore = rs.getLong("id_connettore_risp");
  1443.             }

  1445.             return idConnettore;

  1447.         }catch (Exception e) {
  1448.             throw new DriverConfigurazioneException(e);
  1449.         }finally
  1450.         {
  1451.             //Chiudo statement and resultset
  1452.             JDBCUtilities.closeResources(rs, stm);

  1454.         }
  1455.     }

  1457.     protected static long getIdConnettoreSAINV(long idServizioApplicativo,Connection con) throws DriverConfigurazioneException
  1458.     {
  1459.         PreparedStatement stm = null;
  1460.         ResultSet rs = null;
  1461.         long idConnettore=-1;
  1462.         try
  1463.         {
  1464.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  1465.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1466.             sqlQueryObject.addSelectField("*");
  1467.             sqlQueryObject.addWhereCondition("id = ?");
  1468.             String query = sqlQueryObject.createSQLQuery();
  1469.             stm=con.prepareStatement(query);
  1470.             stm.setLong(1, idServizioApplicativo);
  1471.             rs=stm.executeQuery();

  1473.             if(rs.next()){
  1474.                 idConnettore = rs.getLong("id_connettore_inv");
  1475.             }

  1477.             return idConnettore;

  1479.         }catch (Exception e) {
  1480.             throw new DriverConfigurazioneException(e);
  1481.         }finally
  1482.         {
  1483.             //Chiudo statement and resultset
  1484.             JDBCUtilities.closeResources(rs,stm);

  1486.         }
  1487.     }

  1489.     
  1490. }
Created with JaCoCo 0.8.8.202204050719