DriverRegistroServiziDB_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.  */



  23. package org.openspcoop2.core.registry.driver.db;

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

  35. import org.apache.commons.lang.StringUtils;
  36. import org.openspcoop2.core.byok.BYOKWrappedValue;
  37. import org.openspcoop2.core.byok.IDriverBYOK;
  38. import org.openspcoop2.core.constants.CostantiConnettori;
  39. import org.openspcoop2.core.constants.CostantiDB;
  40. import org.openspcoop2.core.constants.TipiConnettore;
  41. import org.openspcoop2.core.registry.Connettore;
  42. import org.openspcoop2.core.registry.Property;
  43. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  44. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  45. import org.openspcoop2.utils.sql.ISQLQueryObject;
  46. import org.openspcoop2.utils.sql.SQLObjectFactory;

  48. /**
  49.  * Classe utilizzata per effettuare query ad un registro dei servizi openspcoop
  50.  * formato db.
  51.  * 
  52.  * 
  53.  * @author Sandra Giangrandi (sandra@link.it)
  54.  * @author Stefano Corallo (corallo@link.it)
  55.  * @author $Author$
  56.  * @version $Rev$, $Date$
  57.  */
  58. public class DriverRegistroServiziDB_connettoriLIB {


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

  76.         if(connettore == null) throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDConnettore] L'oggetto Connettore non puo essere NULL.");
  77.         if (type!=CostantiDB.DELETE &&
  78.             (connettore.getNome() == null || connettore.getNome().trim().equals("")) 
  79.             ){
  80.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDConnettore] il nome connettore non puo essere NULL.");
  81.         }

  83.         String nomeConnettore = null;
  84.         String endpointtype = null;
  85.         boolean debug = false;
  86.         String url = null;
  87.         String nome = null;
  88.         String tipo = null;
  89.         String utente = null;
  90.         String password = null;
  91.         String initcont = null;
  92.         String urlpkg = null;
  93.         String provurl = null;
  94.         String connectionfactory = null;
  95.         String sendas = null;

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

  100.         boolean proxy = false;
  101.         String proxyType = null;
  102.         String proxyHostname = null;
  103.         String proxyPort = null;
  104.         String proxyUsername = null;
  105.         String proxyPassword = null;
  106.         
  107.         Integer tempiRispostaConnectionTimeout = null;
  108.         Integer tempiRispostaReadTimeout = null;
  109.         Integer tempiRispostaAvgResponseTime = null;

  111.         String redirectMode = null; // in caso di tipo http e https
  112.         Integer redirectMaxHop = null; // in caso di tipo http e https
  113.         
  114.         String tokenPolicy = null;
  115.         
  116.         String apiKey = null;
  117.         String apiKeyHeader = null;
  118.         String appId = null;
  119.         String appIdHeader = null;
  120.         
  121.         // setto i dati, se le property non sono presenti il loro valore rimarra
  122.         // a null e verra settato come tale nel DB
  123.         String nomeProperty = null;
  124.         String valoreProperty = null;

  126.         boolean isAbilitato = false;
  127.         
  128.         nomeConnettore = connettore.getNome();
  129.         endpointtype = connettore.getTipo();

  131.         if (endpointtype == null || endpointtype.trim().equals(""))
  132.             endpointtype = TipiConnettore.DISABILITATO.getNome();

  134.         Map<String, String> extendedProperties = new HashMap<>();
  135.         
  136.         List<String> propertiesGestiteAttraversoColonneAdHoc = new ArrayList<>();
  137.         
  138.         for (int i = 0; i < connettore.sizePropertyList(); i++) {
  139.             nomeProperty = connettore.getProperty(i).getNome();

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

  145.             // Debug
  146.             if (nomeProperty.equals(CostantiDB.CONNETTORE_DEBUG) &&
  147.                 "true".equals(valoreProperty)){
  148.                 debug=true;
  149.             }
  150.             
  151.             // Proxy
  152.             if (nomeProperty.equals(CostantiDB.CONNETTORE_PROXY_TYPE)){
  153.                 proxy = true;
  154.                 proxyType = valoreProperty;
  155.                 
  156.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  157.                 
  158.                 // cerco altri valori del proxy
  159.                 for (Property propertyCheck: connettore.getPropertyList()) {
  160.                     if (propertyCheck.getNome().equals(CostantiDB.CONNETTORE_PROXY_HOSTNAME)){
  161.                         propertiesGestiteAttraversoColonneAdHoc.add(propertyCheck.getNome());
  162.                         proxyHostname = propertyCheck.getValore();
  163.                     }
  164.                     if (propertyCheck.getNome().equals(CostantiDB.CONNETTORE_PROXY_PORT)){
  165.                         propertiesGestiteAttraversoColonneAdHoc.add(propertyCheck.getNome());
  166.                         proxyPort = propertyCheck.getValore();
  167.                     }
  168.                     if (propertyCheck.getNome().equals(CostantiDB.CONNETTORE_PROXY_USERNAME)){
  169.                         propertiesGestiteAttraversoColonneAdHoc.add(propertyCheck.getNome());
  170.                         proxyUsername = propertyCheck.getValore();
  171.                     }
  172.                     if (propertyCheck.getNome().equals(CostantiDB.CONNETTORE_PROXY_PASSWORD)){
  173.                         propertiesGestiteAttraversoColonneAdHoc.add(propertyCheck.getNome());
  174.                         proxyPassword = propertyCheck.getValore();
  175.                     }
  176.                 }
  177.             }
  178.             
  179.             // Tempi Risposta
  180.             if (nomeProperty.equals(CostantiDB.CONNETTORE_CONNECTION_TIMEOUT)){
  181.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  182.                 tempiRispostaConnectionTimeout = Integer.parseInt(valoreProperty);
  183.             }
  184.             if (nomeProperty.equals(CostantiDB.CONNETTORE_READ_CONNECTION_TIMEOUT)){
  185.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  186.                 tempiRispostaReadTimeout = Integer.parseInt(valoreProperty);
  187.             }
  188.             if (nomeProperty.equals(CostantiDB.CONNETTORE_TEMPO_MEDIO_RISPOSTA)){
  189.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  190.                 tempiRispostaAvgResponseTime = Integer.parseInt(valoreProperty);
  191.             }
  192.             
  193.             // TransferMode
  194.             if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_DATA_TRANSFER_MODE)){
  195.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  196.                 transferMode = valoreProperty;
  197.             }
  198.             if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_DATA_TRANSFER_MODE_CHUNK_SIZE)){
  199.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  200.                 transferModeChunkSize = Integer.parseInt(valoreProperty);
  201.             }
  202.             
  203.             // RedirectMode
  204.             if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_REDIRECT_FOLLOW)){
  205.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  206.                 redirectMode = valoreProperty;
  207.             }
  208.             if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_REDIRECT_MAX_HOP)){
  209.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  210.                 redirectMaxHop = Integer.parseInt(valoreProperty);
  211.             }
  212.             
  213.             // TokenPolicy
  214.             if (nomeProperty.equals(CostantiDB.CONNETTORE_TOKEN_POLICY)){
  215.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  216.                 tokenPolicy = valoreProperty;
  217.             }
  218.             
  219.             // ApiKey
  220.             if (nomeProperty.equals(CostantiDB.CONNETTORE_APIKEY)){
  221.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  222.                 apiKey = valoreProperty;
  223.             }
  224.             if (nomeProperty.equals(CostantiDB.CONNETTORE_APIKEY_HEADER)){
  225.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  226.                 apiKeyHeader = valoreProperty;
  227.             }
  228.             if (nomeProperty.equals(CostantiDB.CONNETTORE_APIKEY_APPID)){
  229.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  230.                 appId = valoreProperty;
  231.             }
  232.             if (nomeProperty.equals(CostantiDB.CONNETTORE_APIKEY_APPID_HEADER)){
  233.                 propertiesGestiteAttraversoColonneAdHoc.add(nomeProperty);
  234.                 appIdHeader = valoreProperty;
  235.             }
  236.             
  237.             if(TipiConnettore.HTTP.getNome().equals(endpointtype)){
  238.                 if (nomeProperty.equals(CostantiDB.CONNETTORE_HTTP_LOCATION))
  239.                     url = valoreProperty;
  240.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_USER))
  241.                     utente = valoreProperty;
  242.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_PWD))
  243.                     password = valoreProperty;
  244.             }
  245.             else if(TipiConnettore.JMS.getNome().equals(endpointtype)){
  246.                 if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_NOME))
  247.                     nome = valoreProperty;
  248.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_TIPO))
  249.                     tipo = valoreProperty;
  250.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_USER))
  251.                     utente = valoreProperty;
  252.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_PWD))
  253.                     password = valoreProperty;
  254.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_FACTORY_INITIAL))
  255.                     initcont = valoreProperty;
  256.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_FACTORY_URL_PKG))
  257.                     urlpkg = valoreProperty;
  258.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_CONTEXT_JAVA_NAMING_PROVIDER_URL))
  259.                     provurl = valoreProperty;
  260.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_CONNECTION_FACTORY))
  261.                     connectionfactory = valoreProperty;
  262.                 else if (nomeProperty.equals(CostantiDB.CONNETTORE_JMS_SEND_AS))
  263.                     sendas = valoreProperty;
  264.             }

  266.             // se endpointype != disabilitato allora lo setto abilitato
  267.             if (!endpointtype.equalsIgnoreCase(TipiConnettore.DISABILITATO.getNome()))
  268.                 isAbilitato = true;
  269.             
  270.             // extendedProperties
  271.             if(nomeProperty.startsWith(CostantiConnettori.CONNETTORE_EXTENDED_PREFIX)){
  272.                 extendedProperties.put(nomeProperty, valoreProperty);
  273.             }
  274.         }

  276.         try {

  278.             long idConnettore = 0;
  279.             switch (type) {
  280.             case 1:

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

  322.                 int index = 1;
  323.                 stm.setString(index++, endpointtype);
  324.                 stm.setString(index++, url);
  325.                 stm.setString(index++, (isAbilitato ? transferMode : null));
  326.                 if(isAbilitato && transferModeChunkSize!=null){
  327.                     stm.setInt(index++, transferModeChunkSize);
  328.                 }
  329.                 else{
  330.                     stm.setNull(index++, Types.INTEGER);
  331.                 }
  332.                 stm.setString(index++, (isAbilitato ? redirectMode : null));
  333.                 if(isAbilitato && redirectMaxHop!=null){
  334.                     stm.setInt(index++, redirectMaxHop);
  335.                 }
  336.                 else{
  337.                     stm.setNull(index++, Types.INTEGER);
  338.                 }
  339.                 stm.setString(index++, isAbilitato ? nome : null);
  340.                 stm.setString(index++, isAbilitato ? tipo : null);
  341.                 stm.setString(index++, (isAbilitato ? utente : null));
  342.                 
  343.                 String plainPassword = isAbilitato ? password : null;
  344.                 String encPassword = null;
  345.                 if(isAbilitato && driverBYOK!=null && plainPassword!=null) {
  346.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainPassword);
  347.                     if(byokValue!=null) {
  348.                         encPassword = byokValue.getWrappedValue();
  349.                         plainPassword = byokValue.getWrappedPlainValue();
  350.                     }
  351.                 }
  352.                 stm.setString(index++, plainPassword);
  353.                 stm.setString(index++, encPassword);
  354.                 
  355.                 stm.setString(index++, (isAbilitato ? initcont : null));
  356.                 stm.setString(index++, (isAbilitato ? urlpkg : null));
  357.                 stm.setString(index++, (isAbilitato ? provurl : null));
  358.                 stm.setString(index++, (isAbilitato ? connectionfactory : null));
  359.                 stm.setString(index++, (isAbilitato ? sendas : null));
  360.                 stm.setString(index++, nomeConnettore);
  361.                 if(debug){
  362.                     stm.setInt(index++, 1);
  363.                 }else{
  364.                     stm.setInt(index++, 0);
  365.                 }
  366.                 if(proxy){
  367.                     stm.setInt(index++, 1);
  368.                 }else{
  369.                     stm.setInt(index++, 0);
  370.                 }
  371.                 stm.setString(index++, isAbilitato && proxy ? proxyType : null);
  372.                 stm.setString(index++, isAbilitato && proxy ? proxyHostname : null);
  373.                 stm.setString(index++, isAbilitato && proxy ? proxyPort : null);
  374.                 stm.setString(index++, isAbilitato && proxy ? proxyUsername : null);
  375.                 
  376.                 String plainProxyPassword = isAbilitato ? proxyPassword : null;
  377.                 String encProxyPassword = null;
  378.                 if(isAbilitato && driverBYOK!=null && plainProxyPassword!=null) {
  379.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainProxyPassword);
  380.                     if(byokValue!=null) {
  381.                         encProxyPassword = byokValue.getWrappedValue();
  382.                         plainProxyPassword = byokValue.getWrappedPlainValue();
  383.                     }
  384.                 }
  385.                 stm.setString(index++, plainProxyPassword);
  386.                 stm.setString(index++, encProxyPassword);
  387.                 
  388.                 if(tempiRispostaConnectionTimeout!=null) {
  389.                     stm.setInt(index++, tempiRispostaConnectionTimeout);
  390.                 }
  391.                 else {
  392.                     stm.setNull(index++, Types.INTEGER);
  393.                 }
  394.                 if(tempiRispostaReadTimeout!=null) {
  395.                     stm.setInt(index++, tempiRispostaReadTimeout);
  396.                 }
  397.                 else {
  398.                     stm.setNull(index++, Types.INTEGER);
  399.                 }
  400.                 if(tempiRispostaAvgResponseTime!=null) {
  401.                     stm.setInt(index++, tempiRispostaAvgResponseTime);
  402.                 }
  403.                 else {
  404.                     stm.setNull(index++, Types.INTEGER);
  405.                 }
  406.                 if(connettore.getCustom()!=null && connettore.getCustom()){
  407.                     stm.setInt(index++, 1);
  408.                 }else{
  409.                     stm.setInt(index++, 0);
  410.                 }
  411.                 stm.setString(index++, tokenPolicy);
  412.                 
  413.                 String apiKeyInsert = isAbilitato ? apiKey : null;
  414.                 if(isAbilitato && apiKey!=null && StringUtils.isNotEmpty(apiKey) && driverBYOK!=null && CostantiConnettori.isConfidential(CostantiDB.CONNETTORE_APIKEY)) {
  415.                     BYOKWrappedValue byokValue = driverBYOK.wrap(apiKey);
  416.                     if(byokValue!=null) {
  417.                         apiKeyInsert = byokValue.getWrappedValue();
  418.                         stm.setString(index++, byokValue.getWrappedValue());
  419.                     }
  420.                     else {
  421.                         stm.setString(index++, apiKey);
  422.                     }
  423.                 }
  424.                 else {
  425.                     stm.setString(index++, apiKey);
  426.                 }
  427.                 stm.setString(index++, isAbilitato ? apiKeyHeader : null);
  428.                 stm.setString(index++, isAbilitato ? appId : null);
  429.                 stm.setString(index++, isAbilitato ? appIdHeader : null);
  430.                 
  431.                 DriverRegistroServiziDB_LIB.logDebug("CRUDConnettore CREATE : \n" + 
  432.                         DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, endpointtype, url, 
  433.                                 transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  434.                                 nome, tipo, utente, plainPassword, encPassword, 
  435.                                 initcont, urlpkg, provurl, connectionfactory, sendas, nomeConnettore, debug, 
  436.                                 proxy, proxyType, proxyHostname, proxyPort, proxyUsername, plainProxyPassword, encProxyPassword,
  437.                                 tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaAvgResponseTime,
  438.                                 (connettore.getCustom()!=null && connettore.getCustom()),
  439.                                 tokenPolicy,
  440.                                 apiKeyInsert, apiKeyHeader, appId, appIdHeader));
  441.                 int n = stm.executeUpdate();
  442.                 DriverRegistroServiziDB_LIB.logDebug("CRUDConnettore type = " + type + " row affected =" + n);
  443.                 stm.close();
  444.                 
  445.                 ResultSet rs;
  446.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  447.                 sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  448.                 sqlQueryObject.addSelectField("*");
  449.                 sqlQueryObject.addWhereCondition("nome_connettore = ?");
  450.                 sqlQueryObject.addWhereCondition("endpointtype = ?");
  451.                 sqlQueryObject.setANDLogicOperator(true);
  452.                 sqlQuery = sqlQueryObject.createSQLQuery();
  453.                 stm = connection.prepareStatement(sqlQuery);

  455.                 stm.setString(1, nomeConnettore);
  456.                 stm.setString(2, endpointtype);

  458.                 DriverRegistroServiziDB_LIB.logDebug("Recupero idConnettore inserito : \n" + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, nomeConnettore, endpointtype));

  460.                 rs = stm.executeQuery();

  462.                 if (rs.next()) {
  463.                     idConnettore = rs.getLong("id");
  464.                 } else {
  465.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDConnettore] Errore tentanto di effettuare la select dopo una create, non riesco a recuperare l'id!");
  466.                 }

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

  554.             case 2:
  555.                 // update

  557.                 idConnettore = connettore.getId();

  559.                 if (idConnettore <= 0)
  560.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDConnettore] L'id del connettore non puo essere 0 tentando di fare una operazione di update.");

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

  602.                 index = 1;
  603.                 stm.setString(index++, endpointtype);
  604.                 stm.setString(index++, url);
  605.                 stm.setString(index++, (isAbilitato ? transferMode : null));
  606.                 if(isAbilitato && transferModeChunkSize!=null){
  607.                     stm.setInt(index++, transferModeChunkSize);
  608.                 }
  609.                 else{
  610.                     stm.setNull(index++, Types.INTEGER);
  611.                 }
  612.                 stm.setString(index++, (isAbilitato ? redirectMode : null));
  613.                 if(isAbilitato && redirectMaxHop!=null){
  614.                     stm.setInt(index++, redirectMaxHop);
  615.                 }
  616.                 else{
  617.                     stm.setNull(index++, Types.INTEGER);
  618.                 }
  619.                 stm.setString(index++, isAbilitato ? nome : null);
  620.                 stm.setString(index++, isAbilitato ? tipo : null);
  621.                 stm.setString(index++, (isAbilitato ? utente : null));

  623.                 plainPassword = isAbilitato ? password : null;
  624.                 encPassword = null;
  625.                 if(isAbilitato && driverBYOK!=null && plainPassword!=null) {
  626.                     BYOKWrappedValue byokValue = driverBYOK.wrap(plainPassword);
  627.                     if(byokValue!=null) {
  628.                         encPassword = byokValue.getWrappedValue();
  629.                         plainPassword = byokValue.getWrappedPlainValue();
  630.                     }
  631.                 }
  632.                 stm.setString(index++, plainPassword);
  633.                 stm.setString(index++, encPassword);
  634.                 
  635.                 stm.setString(index++, (isAbilitato ? initcont : null));
  636.                 stm.setString(index++, (isAbilitato ? urlpkg : null));
  637.                 stm.setString(index++, (isAbilitato ? provurl : null));
  638.                 stm.setString(index++, (isAbilitato ? connectionfactory : null));
  639.                 stm.setString(index++, (isAbilitato ? sendas : null));
  640.                 stm.setString(index++, nomeConnettore);
  641.                 if(debug){
  642.                     stm.setInt(index++, 1);
  643.                 }else{
  644.                     stm.setInt(index++, 0);
  645.                 }
  646.                 if(proxy){
  647.                     stm.setInt(index++, 1);
  648.                 }else{
  649.                     stm.setInt(index++, 0);
  650.                 }
  651.                 stm.setString(index++, isAbilitato && proxy ? proxyType : null);
  652.                 stm.setString(index++, isAbilitato && proxy ? proxyHostname : null);
  653.                 stm.setString(index++, isAbilitato && proxy ? proxyPort : null);
  654.                 stm.setString(index++, isAbilitato && proxy ? proxyUsername : null);

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

  713.                 DriverRegistroServiziDB_LIB.logDebug("CRUDConnettore UPDATE : \n" + 
  714.                         DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, endpointtype, url, 
  715.                                 transferMode, transferModeChunkSize, redirectMode, redirectMaxHop,
  716.                                 nome, tipo, utente, plainPassword, encPassword, 
  717.                                 initcont, urlpkg, provurl, connectionfactory, sendas, nomeConnettore, debug,
  718.                                 proxy, proxyType, proxyHostname, proxyPort, proxyUsername, plainProxyPassword, encProxyPassword,
  719.                                 tempiRispostaConnectionTimeout, tempiRispostaReadTimeout, tempiRispostaAvgResponseTime,
  720.                                 (connettore.getCustom()!=null && connettore.getCustom()),
  721.                                 tokenPolicy,
  722.                                 apiKeyInsert, apiKeyHeader, appId, appIdHeader,
  723.                                 idConnettore));
  724.                 n = stm.executeUpdate();
  725.                 DriverRegistroServiziDB_LIB.logDebug("CRUDConnettore type = " + type + " row affected =" + n);
  726.                 stm.close();
  727.                 
  728.                 
  729.                 // Custom properties
  730.                 
  731.                 // Delete eventuali vecchie properties
  732.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  733.                 sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI_CUSTOM);
  734.                 sqlQueryObject.addWhereCondition("id_connettore=?");
  735.                 sqlQuery = sqlQueryObject.createSQLDelete();
  736.                 stm = connection.prepareStatement(sqlQuery);
  737.                 stm.setLong(1, idConnettore);
  738.                 stm.executeUpdate();
  739.                 stm.close();
  740.                 
  741.                 // Aggiungo attuali
  742.                 if(connettore.getCustom()!=null && connettore.getCustom()){                 
  743.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  744.                     sqlQueryObject.addInsertTable(CostantiDB.CONNETTORI_CUSTOM);
  745.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME, "?");
  746.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE, "?");
  747.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE, "?");
  748.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ID_CONNETTORE, "?");
  749.                     sqlQuery = sqlQueryObject.createSQLInsert();
  750.                     
  751.                     for (int i = 0; i < connettore.sizePropertyList(); i++) {
  752.                         nomeProperty = connettore.getProperty(i).getNome();
  753.                         if(propertiesGestiteAttraversoColonneAdHoc.contains(nomeProperty)){
  754.                             continue;
  755.                         }
  756.                         valoreProperty = connettore.getProperty(i).getValore();
  757.                         if (valoreProperty != null && valoreProperty.equals(""))
  758.                             valoreProperty = null;
  759.                     
  760.                         if(valoreProperty==null){
  761.                             throw new DriverRegistroServiziException("Property ["+nomeProperty+"] without value");
  762.                         }
  763.                         
  764.                         String plainValue = valoreProperty;
  765.                         String encValue = null;
  766.                         if(driverBYOK!=null && CostantiConnettori.isConfidential(nomeProperty)) {
  767.                             BYOKWrappedValue byokValue = driverBYOK.wrap(valoreProperty);
  768.                             if(byokValue!=null) {
  769.                                 encValue = byokValue.getWrappedValue();
  770.                                 plainValue = byokValue.getWrappedPlainValue();
  771.                             }
  772.                         }
  773.                         
  774.                         stm = connection.prepareStatement(sqlQuery);
  775.                         stm.setString(1, nomeProperty);
  776.                         stm.setString(2, plainValue);
  777.                         stm.setString(3, encValue);
  778.                         stm.setLong(4, idConnettore);
  779.                         stm.executeUpdate();
  780.                         stm.close();
  781.                     }               
  782.                 }
  783.                 else if(extendedProperties.size()>0){
  784.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  785.                     sqlQueryObject.addInsertTable(CostantiDB.CONNETTORI_CUSTOM);
  786.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_NAME, "?");
  787.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_VALUE, "?");
  788.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ENC_VALUE, "?");
  789.                     sqlQueryObject.addInsertField(CostantiDB.CONNETTORI_CUSTOM_COLUMN_ID_CONNETTORE, "?");
  790.                     sqlQuery = sqlQueryObject.createSQLInsert();
  791.                     
  792.                     for (String nomeP : extendedProperties.keySet()) {
  793.                         valoreProperty = extendedProperties.get(nomeP);
  794.                         if (valoreProperty != null && valoreProperty.equals(""))
  795.                             valoreProperty = null;
  796.                     
  797.                         if(valoreProperty==null){
  798.                             throw new DriverRegistroServiziException("Property ["+nomeP+"] without value");
  799.                         }
  800.                         
  801.                         String plainValue = valoreProperty;
  802.                         String encValue = null;
  803.                         if(driverBYOK!=null && CostantiConnettori.isConfidential(nomeProperty)) {
  804.                             BYOKWrappedValue byokValue = driverBYOK.wrap(valoreProperty);
  805.                             if(byokValue!=null) {
  806.                                 encValue = byokValue.getWrappedValue();
  807.                                 plainValue = byokValue.getWrappedPlainValue();
  808.                             }
  809.                         }
  810.                         
  811.                         stm = connection.prepareStatement(sqlQuery);
  812.                         stm.setString(1, nomeP);
  813.                         stm.setString(2, plainValue);
  814.                         stm.setString(3, encValue);
  815.                         stm.setLong(4, idConnettore);
  816.                         stm.executeUpdate();
  817.                         stm.close();
  818.                     }           
  819.                 }
  820.                 
  821.                 break;

  823.             case 3:
  824.                 // delete
  825.                 idConnettore = connettore.getId();

  827.                 if (idConnettore <= 0)
  828.                     throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDConnettore] L'id del connettore non puo essere 0 tentando di fare una operazione di delete.");

  830.                 // Delete eventuali vecchie properties
  831.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  832.                 sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI_CUSTOM);
  833.                 sqlQueryObject.addWhereCondition("id_connettore=?");
  834.                 sqlQuery = sqlQueryObject.createSQLDelete();
  835.                 stm = connection.prepareStatement(sqlQuery);
  836.                 stm.setLong(1, idConnettore);
  837.                 stm.executeUpdate();
  838.                 stm.close();
  839.                 
  840.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverRegistroServiziDB_LIB.tipoDB);
  841.                 sqlQueryObject.addDeleteTable(CostantiDB.CONNETTORI);
  842.                 sqlQueryObject.addWhereCondition("id=?");
  843.                 sqlQuery = sqlQueryObject.createSQLDelete();
  844.                 stm = connection.prepareStatement(sqlQuery);
  845.                 stm.setLong(1, idConnettore);
  846.                 DriverRegistroServiziDB_LIB.logDebug("CRUDConnettore DELETE : \n" + DriverRegistroServiziDB_LIB.formatSQLString(sqlQuery, idConnettore));
  847.                 n = stm.executeUpdate();
  848.                 DriverRegistroServiziDB_LIB.logDebug("CRUDConnettore type = " + type + " row affected =" + n);
  849.                 stm.close();
  850.                 
  851.                 break;
  852.             }

  854.             // ritorno l id del connettore questo e' utile in caso di create
  855.             connettore.setId(idConnettore);
  856.             return idConnettore;

  858.         } catch (SQLException se) {
  859.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDConnettore] SQLException : " + se.getMessage(),se);
  860.         } catch (Exception se) {
  861.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB_LIB::CRUDConnettore] Exception : " + se.getMessage(),se);
  862.         }finally {
  863.             JDBCUtilities.closeResources(stm);
  864.         }
  865.     }
  866.     

  868. }
Created with JaCoCo 0.8.8.202204050719