DriverConfigurazioneDB_connettoriDriver.java

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

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

  28. import org.apache.commons.lang.StringUtils;
  29. import org.openspcoop2.core.byok.IDriverBYOK;
  30. import org.openspcoop2.core.config.Connettore;
  31. import org.openspcoop2.core.config.Property;
  32. import org.openspcoop2.core.config.driver.ConnettorePropertiesUtilities;
  33. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  34. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  35. import org.openspcoop2.core.constants.CostantiConnettori;
  36. import org.openspcoop2.core.constants.CostantiDB;
  37. import org.openspcoop2.utils.UtilsException;
  38. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  39. import org.openspcoop2.utils.sql.ISQLQueryObject;
  40. import org.openspcoop2.utils.sql.SQLObjectFactory;

  42. /**
  43.  * DriverConfigurazioneDB_connettoriDriver
  44.  * 
  45.  * 
  46.  * @author Sandra Giangrandi (sandra@link.it)
  47.  * @author Stefano Corallo (corallo@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public class DriverConfigurazioneDB_connettoriDriver {

  53.     private DriverConfigurazioneDB driver = null;
  54.     
  55.     protected DriverConfigurazioneDB_connettoriDriver(DriverConfigurazioneDB driver) {
  56.         this.driver = driver;
  57.     }
  58.     
  59.     protected void createConnettore(Connettore connettore) throws DriverConfigurazioneException {
  60.         if (connettore == null)
  61.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createConnettore] Parametro non valido.");

  63.         Connection con = null;
  64.         boolean error = false;

  66.         if (this.driver.atomica) {
  67.             try {
  68.                 con = this.driver.getConnectionFromDatasource("createConnettore");
  69.                 con.setAutoCommit(false);
  70.             } catch (Exception e) {
  71.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createConnettore] Exception accedendo al datasource :" + e.getMessage(),e);

  73.             }

  75.         } else
  76.             con = this.driver.globalConnection;

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

  80.         try {
  81.             this.driver.logDebug("CRUDConnettore type = 1");
  82.             // creo connettore
  83.             DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(1, connettore, con, this.driver.getDriverWrapBYOK());

  85.         } catch (Exception qe) {
  86.             error = true;
  87.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createConnettore] Errore durante la creazione del connettore : " + qe.getMessage(),qe);
  88.         } finally {
  89.             this.driver.closeConnection(error,con);
  90.         }
  91.     }

  93.     protected void updateConnettore(Connettore connettore) throws DriverConfigurazioneException {
  94.         if (connettore == null)
  95.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateConnettore] Parametro non valido.");

  97.         Connection con = null;
  98.         boolean error = false;

  100.         if (this.driver.atomica) {
  101.             try {
  102.                 con = this.driver.getConnectionFromDatasource("updateConnettore");
  103.                 con.setAutoCommit(false);
  104.             } catch (Exception e) {
  105.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateConnettore] Exception accedendo al datasource :" + e.getMessage(),e);

  107.             }

  109.         } else
  110.             con = this.driver.globalConnection;

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

  114.         try {
  115.             this.driver.logDebug("CRUDConnettore type = 2");
  116.             // update connettore
  117.             DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(2, connettore, con, this.driver.getDriverWrapBYOK());

  119.         } catch (Exception qe) {
  120.             error = true;
  121.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateConnettore] Errore durante l'aggiornamento del connettore : " + qe.getMessage(),qe);
  122.         } finally {

  124.             this.driver.closeConnection(error,con);
  125.         }
  126.     }

  128.     protected void deleteConnettore(Connettore connettore) throws DriverConfigurazioneException {
  129.         if (connettore == null)
  130.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteConnettore] Parametro non valido.");

  132.         Connection con = null;
  133.         boolean error = false;

  135.         if (this.driver.atomica) {
  136.             try {
  137.                 con = this.driver.getConnectionFromDatasource("deleteConnettore");
  138.                 con.setAutoCommit(false);
  139.             } catch (Exception e) {
  140.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteConnettore] Exception accedendo al datasource :" + e.getMessage(),e);

  142.             }

  144.         } else
  145.             con = this.driver.globalConnection;

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

  149.         try {
  150.             this.driver.logDebug("CRUDConnettore type = 3");
  151.             // delete connettore
  152.             DriverConfigurazioneDB_connettoriLIB.CRUDConnettore(3, connettore, con, this.driver.getDriverWrapBYOK());

  154.         } catch (Exception qe) {
  155.             error = true;
  156.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteConnettore] Errore durante la rimozione del connettore : " + qe.getMessage(),qe);
  157.         } finally {

  159.             this.driver.closeConnection(error,con);
  160.         }
  161.     }
  162.     
  163.     protected List<String> connettoriList() throws DriverConfigurazioneException {
  164.         String nomeMetodo = "connettoriList";
  165.         Connection con = null;
  166.         PreparedStatement stmt=null;
  167.         ResultSet risultato=null;
  168.         ArrayList<String> lista = new ArrayList<>();

  170.         if (this.driver.atomica) {
  171.             try {
  172.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  173.             } catch (Exception e) {
  174.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  176.             }

  178.         } else
  179.             con = this.driver.globalConnection;

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

  183.         try {

  185.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  186.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI_PROPERTIES);
  187.             sqlQueryObject.addSelectField(CostantiDB.CONNETTORI_COLUMN_NOME);
  188.             String queryString = sqlQueryObject.createSQLQuery();
  189.             stmt = con.prepareStatement(queryString);
  190.             risultato = stmt.executeQuery();

  192.             while (risultato.next())
  193.                 lista.add(risultato.getString(CostantiDB.CONNETTORI_COLUMN_NOME));

  195.             return lista;

  197.         } catch (Exception qe) {
  198.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  199.         } finally {

  201.             //Chiudo statement and resultset
  202.             JDBCUtilities.closeResources(risultato, stmt);

  204.             this.driver.closeConnection(con);
  205.         }
  206.     }
  207.     
  208.     protected Property[] getPropertiesConnettore(String nomeConnettore) throws DriverConfigurazioneException {
  209.         Connection con = null;
  210.         if (this.driver.atomica) {
  211.             try {
  212.                 con = this.driver.getConnectionFromDatasource("getPropertiesConnettore");

  214.             } catch (Exception e) {
  215.                 throw new DriverConfigurazioneException("[DriverDB::getPropertiesConnettore] Exception accedendo al datasource :" + e.getMessage(),e);

  217.             }

  219.         } else
  220.             con = this.driver.globalConnection;
  221.         return getPropertiesConnettore(nomeConnettore,con);
  222.     }
  223.     protected Property[] getPropertiesConnettore(String nomeConnettore, Connection connection) throws DriverConfigurazioneException {
  224.         try {
  225.             List<Property> cList = ConnettorePropertiesUtilities.getPropertiesConnettore(nomeConnettore, connection,this.driver.tipoDB);
  226.             return cList.toArray(new Property[cList.size()]);
  227.         } catch (Exception e) {
  228.             throw new DriverConfigurazioneException("[DriverDB::getPropertiesConnettore] DriverConfigurazioneException : " + e.getMessage(),e);
  229.         }
  230.     }
  231.     
  232.     
  233.     protected boolean isPolicyNegoziazioneTokenUsedInConnettore(String nome) throws DriverConfigurazioneException{
  234.         String nomeMetodo = "isPolicyNegoziazioneTokenUsedInConnettore";

  236.         Connection con = null;
  237.         PreparedStatement stmt=null;
  238.         ResultSet risultato=null;
  239.         
  240.         if (this.driver.atomica) {
  241.             try {
  242.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  243.             } catch (Exception e) {
  244.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  246.             }

  248.         } else
  249.             con = this.driver.globalConnection;

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

  253.         try {

  255.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  256.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  257.             sqlQueryObject.addSelectField("id");
  258.             sqlQueryObject.addWhereCondition("token_policy=?");
  259.             String queryString = sqlQueryObject.createSQLQuery();
  260.             stmt = con.prepareStatement(queryString);
  261.             stmt.setString(1, nome);
  262.             risultato = stmt.executeQuery();

  264.             return risultato.next();

  266.         } catch (Exception qe) {
  267.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  268.         } finally {
  269.             //Chiudo statement and resultset
  270.             JDBCUtilities.closeResources(risultato, stmt);
  271.             this.driver.closeConnection(con);
  272.         }
  273.     }
  274.     
  275.     
  276.     protected Connettore getConnettore(long idConnettore) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  277.         String nomeMetodo = "getConnettore(id)";
  278.         
  279.         Connection con = null;
  280.         if (this.driver.atomica) {
  281.             try {
  282.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  283.             } catch (Exception e) {
  284.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  286.             }

  288.         } else
  289.             con = this.driver.globalConnection;

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

  293.         try {

  295.             Connettore connettore = DriverConfigurazioneDB_connettoriLIB.getConnettore(idConnettore, con, this.driver.getDriverUnwrapBYOK());
  296.             if(connettore==null) {
  297.                 throw new DriverConfigurazioneNotFound("Connettore con id '"+idConnettore+"' non esistente");
  298.             }
  299.                         
  300.             // Recupero anche eventuale username e password in invocazione servizio.
  301.             readCredenzialiBasicConnettore(connettore, idConnettore, con);
  302.             
  303.             return connettore;
  304.             
  305.         } catch (Exception qe) {
  306.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  307.         } finally {

  309.             this.driver.closeConnection(con);
  310.         }
  311.     }
  312.     protected Connettore getConnettore(String nomeConnettore) throws DriverConfigurazioneException {
  313.         String nomeMetodo = "getConnettore(nome)";
  314.         
  315.         Connection con = null;
  316.         PreparedStatement stmt=null;
  317.         ResultSet risultato=null;
  318.         
  319.         if (this.driver.atomica) {
  320.             try {
  321.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  322.             } catch (Exception e) {
  323.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  325.             }

  327.         } else
  328.             con = this.driver.globalConnection;

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

  332.         try {

  334.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  335.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  336.             sqlQueryObject.addSelectField("id");
  337.             sqlQueryObject.addWhereCondition("nome_connettore=?");
  338.             String queryString = sqlQueryObject.createSQLQuery();
  339.             stmt = con.prepareStatement(queryString);
  340.             stmt.setString(1, nomeConnettore);
  341.             risultato = stmt.executeQuery();

  343.             Long idConnettore = null;
  344.             if (risultato.next()) {
  345.                 idConnettore = risultato.getLong("id");
  346.             }
  347.             else {
  348.                 throw new DriverConfigurazioneNotFound("Connettore con nome '"+nomeConnettore+"' non esistente");
  349.             }
  350.                     
  351.             Connettore connettore = DriverConfigurazioneDB_connettoriLIB.getConnettore(idConnettore, con, this.driver.getDriverUnwrapBYOK());
  352.             if(connettore==null) {
  353.                 throw new DriverConfigurazioneNotFound("Connettore con id '"+idConnettore+"' non esistente");
  354.             }
  355.             
  356.             risultato.close();
  357.             stmt.close();
  358.             
  359.             // Recupero anche eventuale username e password in invocazione servizio.
  360.             readCredenzialiBasicConnettore(connettore, idConnettore, con);
  361.             
  362.             return connettore;
  363.             
  364.         } catch (Exception qe) {
  365.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  366.         } finally {

  368.             //Chiudo statement and resultset
  369.             JDBCUtilities.closeResources(risultato, stmt);

  371.             this.driver.closeConnection(con);
  372.         }
  373.     }
  374.     private void readCredenzialiBasicConnettore(Connettore connettore, long idConnettore,
  375.             Connection con) throws DriverConfigurazioneException {
  376.         String nomeMetodo = "getConnettore(nome)";
  377.         
  378.         PreparedStatement stmt=null;
  379.         ResultSet risultato=null;
  380.         try {
  381.             
  382.             // Recupero anche eventuale username e password in invocazione servizio.
  383.             if(!connettore.getProperties().containsKey(CostantiConnettori.CONNETTORE_USERNAME)) {
  384.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  385.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  386.                 sqlQueryObject.addSelectField("utenteinv");
  387.                 sqlQueryObject.addSelectField("passwordinv");
  388.                 sqlQueryObject.addSelectField("enc_passwordinv");
  389.                 sqlQueryObject.addWhereCondition("id_connettore_inv=?");
  390.                 String queryString = sqlQueryObject.createSQLQuery();
  391.                 stmt = con.prepareStatement(queryString);
  392.                 stmt.setLong(1, idConnettore);
  393.                 risultato = stmt.executeQuery();
  394.                 String user = null;
  395.                 String encPassword = null;
  396.                 String plainPassword = null;
  397.                 if (risultato.next()) {
  398.                     user = risultato.getString("utenteinv");
  399.                     plainPassword = risultato.getString("passwordinv");
  400.                     encPassword = risultato.getString("enc_passwordinv");
  401.                 }
  402.                 else {
  403.                     // cerco come risposta asincrona
  404.                     risultato.close();
  405.                     stmt.close();
  406.                     
  407.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  408.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  409.                     sqlQueryObject.addSelectField("utenterisp");
  410.                     sqlQueryObject.addSelectField("passwordrisp");
  411.                     sqlQueryObject.addSelectField("enc_passwordrisp");
  412.                     sqlQueryObject.addWhereCondition("id_connettore_risp=?");
  413.                     queryString = sqlQueryObject.createSQLQuery();
  414.                     stmt = con.prepareStatement(queryString);
  415.                     stmt.setLong(1, idConnettore);
  416.                     risultato = stmt.executeQuery();
  417.                     if (risultato.next()) {
  418.                         user = risultato.getString("utenterisp");
  419.                         plainPassword = risultato.getString("passwordrisp");
  420.                         encPassword = risultato.getString("enc_passwordrisp");
  421.                     }
  422.                 }
  423.                 
  424.                 setUsernameProperty(user, connettore) ;
  425.                 setPasswordProperty(plainPassword, encPassword, connettore);

  427.             }
  428.             
  429.         } catch (Exception qe) {
  430.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  431.         } finally {

  433.             //Chiudo statement and resultset
  434.             JDBCUtilities.closeResources(risultato, stmt);

  436.         }
  437.     }
  438.     
  439.     private void setUsernameProperty(String user, Connettore connettore) {
  440.         if(user!=null) {
  441.             Property property = new Property();
  442.             property.setNome(CostantiConnettori.CONNETTORE_USERNAME);
  443.             property.setValore(user);
  444.             connettore.addProperty(property);
  445.         }
  446.     }
  447.     private void setPasswordProperty(String plainPassword, String encPassword, Connettore connettore) throws UtilsException {
  448.         if(plainPassword!=null || encPassword!=null) {
  449.             Property property = new Property();
  450.             property.setNome(CostantiConnettori.CONNETTORE_PASSWORD);
  451.             
  452.             if(encPassword!=null && StringUtils.isNotEmpty(encPassword)) {
  453.                 IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  454.                 if(driverBYOK!=null) {
  455.                     property.setValore(driverBYOK.unwrapAsString(encPassword));
  456.                 }
  457.                 else {
  458.                     property.setValore(encPassword);
  459.                 }
  460.             }
  461.             else {
  462.                 property.setValore(plainPassword);
  463.             }
  464.         
  465.             connettore.addProperty(property);
  466.         }
  467.     }
  468. }
Created with JaCoCo 0.8.8.202204050719