DriverConfigurazioneDB_serviziApplicativiDriver.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.sql.SQLException;
  26. import java.sql.Timestamp;
  27. import java.util.ArrayList;
  28. import java.util.HashMap;
  29. import java.util.List;
  30. import java.util.Map;

  32. import org.apache.commons.lang.StringUtils;
  33. import org.openspcoop2.core.byok.IDriverBYOK;
  34. import org.openspcoop2.core.commons.DBUtils;
  35. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  36. import org.openspcoop2.core.config.Connettore;
  37. import org.openspcoop2.core.config.Credenziali;
  38. import org.openspcoop2.core.config.GestioneErrore;
  39. import org.openspcoop2.core.config.InvocazioneCredenziali;
  40. import org.openspcoop2.core.config.InvocazionePorta;
  41. import org.openspcoop2.core.config.InvocazionePortaGestioneErrore;
  42. import org.openspcoop2.core.config.InvocazioneServizio;
  43. import org.openspcoop2.core.config.Proprieta;
  44. import org.openspcoop2.core.config.ProprietaOggetto;
  45. import org.openspcoop2.core.config.ProtocolProperty;
  46. import org.openspcoop2.core.config.RispostaAsincrona;
  47. import org.openspcoop2.core.config.Ruolo;
  48. import org.openspcoop2.core.config.ServizioApplicativo;
  49. import org.openspcoop2.core.config.ServizioApplicativoRuoli;
  50. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  51. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  52. import org.openspcoop2.core.config.constants.InvocazioneServizioTipoAutenticazione;
  53. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  54. import org.openspcoop2.core.config.constants.TipologiaErogazione;
  55. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  56. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  57. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  58. import org.openspcoop2.core.config.driver.FiltroRicercaProtocolPropertyConfig;
  59. import org.openspcoop2.core.config.driver.FiltroRicercaServiziApplicativi;
  60. import org.openspcoop2.core.config.driver.IDServizioUtils;
  61. import org.openspcoop2.core.constants.CostantiDB;
  62. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  63. import org.openspcoop2.core.constants.TipiConnettore;
  64. import org.openspcoop2.core.id.IDServizio;
  65. import org.openspcoop2.core.id.IDServizioApplicativo;
  66. import org.openspcoop2.core.id.IDSoggetto;
  67. import org.openspcoop2.utils.TipiDatabase;
  68. import org.openspcoop2.utils.UtilsException;
  69. import org.openspcoop2.utils.certificate.ArchiveLoader;
  70. import org.openspcoop2.utils.certificate.ArchiveType;
  71. import org.openspcoop2.utils.certificate.Certificate;
  72. import org.openspcoop2.utils.certificate.CertificateInfo;
  73. import org.openspcoop2.utils.certificate.CertificateUtils;
  74. import org.openspcoop2.utils.certificate.PrincipalType;
  75. import org.openspcoop2.utils.crypt.CryptConfig;
  76. import org.openspcoop2.utils.crypt.CryptFactory;
  77. import org.openspcoop2.utils.crypt.ICrypt;
  78. import org.openspcoop2.utils.date.DateManager;
  79. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  80. import org.openspcoop2.utils.jdbc.JDBCAdapterException;
  81. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  82. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  83. import org.openspcoop2.utils.sql.ISQLQueryObject;
  84. import org.openspcoop2.utils.sql.SQLObjectFactory;
  85. import org.openspcoop2.utils.sql.SQLQueryObjectException;

  87. /**
  88.  * DriverConfigurazioneDB_serviziApplicativiDriver
  89.  * 
  90.  * 
  91.  * @author Sandra Giangrandi (sandra@link.it)
  92.  * @author Stefano Corallo (corallo@link.it)
  93.  * @author $Author$
  94.  * @version $Rev$, $Date$
  95.  */
  96. public class DriverConfigurazioneDB_serviziApplicativiDriver {

  98.     private DriverConfigurazioneDB driver = null;
  99.     private DriverConfigurazioneDBSoggetti soggettiDriver = null;
  100.     private DriverConfigurazioneDB_protocolPropertiesDriver protocolPropertiesDriver = null;
  101.     private DriverConfigurazioneDBUtils utilsDriver = null;
  102.     
  103.     protected DriverConfigurazioneDB_serviziApplicativiDriver(DriverConfigurazioneDB driver) {
  104.         this.driver = driver;
  105.         this.soggettiDriver = new DriverConfigurazioneDBSoggetti(driver);
  106.         this.protocolPropertiesDriver = new DriverConfigurazioneDB_protocolPropertiesDriver(driver);
  107.         this.utilsDriver = new DriverConfigurazioneDBUtils(driver);
  108.     }
  109.     

  111.     protected ServizioApplicativo getServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  112.             return this.getEngineServizioApplicativo(idServizioApplicativo, null, null, 
  113.                     null, null, null, false,
  114.                     null, 
  115.                     null,
  116.                     null,
  117.                     false, false,
  118.                     null, null, false,
  119.                     null, false, false, false);
  120.     }
  121.     
  122.     protected ServizioApplicativo getServizioApplicativoByCredenzialiBasic(String aUser,String aPassword, CryptConfig config) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  123.             return this.getEngineServizioApplicativo(null, aUser, aPassword, 
  124.                     null, null, null, false,
  125.                     null, 
  126.                     null,
  127.                     config,
  128.                     false, false,
  129.                     null, null, false,
  130.                     null, false, false, false);
  131.     }
  132.     protected ServizioApplicativo getServizioApplicativoByCredenzialiBasic(String aUser,String aPassword, CryptConfig config,
  133.             List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  134.         return this.getEngineServizioApplicativo(null, aUser, aPassword, 
  135.                 null, null, null, false,
  136.                 null, 
  137.                 null,
  138.                 config,
  139.                 false, false,
  140.                 null, null, false,
  141.                 tipiSoggetto, false, false, false);
  142. }
  143.     
  144.     protected ServizioApplicativo getServizioApplicativoByCredenzialiApiKey(String aUser,String aPassword, boolean appId, CryptConfig config) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  145.             return this.getEngineServizioApplicativo(null, aUser, aPassword, 
  146.                     null, null, null, false,
  147.                     null, 
  148.                     null,
  149.                     config,
  150.                     true, appId,
  151.                     null, null, false,
  152.                     null, false, false, false);
  153.     }
  154.     protected ServizioApplicativo getServizioApplicativoByCredenzialiApiKey(String aUser,String aPassword, boolean appId, CryptConfig config,
  155.             List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  156.         return this.getEngineServizioApplicativo(null, aUser, aPassword, 
  157.                 null, null, null, false,
  158.                 null, 
  159.                 null,
  160.                 config,
  161.                 true, appId,
  162.                 null, null, false,
  163.                 tipiSoggetto, false, false, false);
  164.     }
  165.     
  166.     protected ServizioApplicativo getServizioApplicativoByCredenzialiToken(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  167.             return this.getEngineServizioApplicativo(null, null, null, 
  168.                     null, null, null, false,
  169.                     null, 
  170.                     null,
  171.                     null,
  172.                     false, false,
  173.                     tokenPolicy, tokenClientId, tokenWithHttpsEnabled,
  174.                     null, false, false, false);
  175.     }
  176.     protected ServizioApplicativo getServizioApplicativoByCredenzialiToken(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled,
  177.             List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  178.         return this.getEngineServizioApplicativo(null, null, null, 
  179.                 null, null, null, false,
  180.                 null, 
  181.                 null,
  182.                 null,
  183.                 false, false,
  184.                 tokenPolicy, tokenClientId, tokenWithHttpsEnabled,
  185.                 tipiSoggetto, false, false, false);
  186.     }
  187.     
  188.     protected ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String aSubject, String aIssuer) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  189.             return this.getEngineServizioApplicativo(null, null, null, 
  190.                     aSubject, aIssuer, null, false,
  191.                     null, 
  192.                     null,
  193.                     null,
  194.                     false, false,
  195.                     null, null, false,
  196.                     null, false, false, false);
  197.     }
  198.     protected ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String aSubject, String aIssuer,
  199.             List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  200.         return this.getEngineServizioApplicativo(null, null, null, 
  201.                 aSubject, aIssuer, null, false,
  202.                 null, 
  203.                 null,
  204.                 null,
  205.                 false, false,
  206.                 null, null, false,
  207.                 tipiSoggetto, false, false, false);
  208.     }
  209.     protected ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String aSubject, String aIssuer,
  210.             List<String> tipiSoggetto, boolean includiApplicativiNonModI,boolean includiApplicativiModIEsterni,boolean includiApplicativiModIInterni) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  211.         return this.getEngineServizioApplicativo(null, null, null, 
  212.                 aSubject, aIssuer, null, false,
  213.                 null, 
  214.                 null,
  215.                 null,
  216.                 false, false,
  217.                 null, null, false,
  218.                 tipiSoggetto, includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  219.     }
  220.     
  221.     protected ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  222.          return this.getEngineServizioApplicativo(null, null, null, 
  223.                 null, null, certificate, strictVerifier,
  224.                 null, 
  225.                 null,
  226.                 null,
  227.                 false, false,
  228.                 null, null, false,
  229.                 null, false, false, false);
  230.     }
  231.     protected ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier,
  232.             List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  233.      return this.getEngineServizioApplicativo(null, null, null, 
  234.                 null, null, certificate, strictVerifier,
  235.                 null, 
  236.                 null,
  237.                 null,
  238.                 false, false,
  239.             null, null, false,
  240.             tipiSoggetto, false, false, false);
  241.     }
  242.     protected ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier,
  243.             List<String> tipiSoggetto, boolean includiApplicativiNonModI,boolean includiApplicativiModIEsterni,boolean includiApplicativiModIInterni) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  244.      return this.getEngineServizioApplicativo(null, null, null, 
  245.                 null, null, certificate, strictVerifier,
  246.                 null, 
  247.                 null,
  248.                 null,
  249.                 false, false,
  250.             null, null, false,
  251.             tipiSoggetto, includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  252.     }
  253.     
  254.     protected ServizioApplicativo getServizioApplicativoByCredenzialiPrincipal(String principal) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  255.         return this.getEngineServizioApplicativo(null, null, null, 
  256.                 null, null, null, false,
  257.                 principal, 
  258.                 null,
  259.                 null,
  260.                 false, false,
  261.                 null, null, false,
  262.                 null, false, false, false);
  263.     }
  264.     protected ServizioApplicativo getServizioApplicativoByCredenzialiPrincipal(String principal,
  265.             List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  266.         return this.getEngineServizioApplicativo(null, null, null, 
  267.                 null, null, null, false,
  268.                 principal, 
  269.                 null,
  270.                 null,
  271.                 false, false,
  272.                 null, null, false,
  273.                 tipiSoggetto, false, false, false);
  274.     }
  275.     
  276.     protected ServizioApplicativo getServizioApplicativo(long idServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  277.             return this.getEngineServizioApplicativo(null, null, null, 
  278.                     null, null, null, false,
  279.                     null, 
  280.                     idServizioApplicativo,
  281.                     null,
  282.                     false, false,
  283.                     null, null, false,
  284.                     null, false, false, false);
  285.     }

  287.     private ServizioApplicativo getEngineServizioApplicativo(IDServizioApplicativo idServizioApplicativoObject, 
  288.             String aUser, String aPassord, 
  289.             String aSubject, String aIssuer, CertificateInfo aCertificate, boolean aStrictVerifier, 
  290.             String principal,
  291.             Long idServizioApplicativo, 
  292.             CryptConfig config,
  293.             boolean apiKey, boolean appId,
  294.             String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled,
  295.             List<String> tipiSoggetto, boolean includiApplicativiNonModI,boolean includiApplicativiModIEsterni,boolean includiApplicativiModIInterni) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {

  297.         Connection con = null;
  298.         PreparedStatement stm = null;
  299.         ResultSet rs = null;
  300.         String nome_sa = null;
  301.         String sqlQuery = null;
  302.         ServizioApplicativo sa = null;

  304.         int type = 0;
  305.         final int TYPE_ID_OBJECT = 1;
  306.         final int TYPE_BASIC = 2;
  307.         final int TYPE_SSL_SUBJECT_ISSUER = 31;
  308.         final int TYPE_SSL_CERTIFICATE = 32;
  309.         final int TYPE_PRINCIPAL = 4;
  310.         final int TYPE_ID_LONG = 5;
  311.         final int TYPE_API_KEY = 6;
  312.         final int TYPE_TOKEN = 7;
  313.         if(idServizioApplicativoObject!=null){
  314.             IDSoggetto idSO = idServizioApplicativoObject.getIdSoggettoProprietario();
  315.             if(idSO==null)throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Soggetto Proprietario non definito.");
  316.             if(idSO.getNome()==null || "".equals(idSO.getNome()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Nome Soggetto Proprietario non definito.");
  317.             if(idSO.getTipo()==null || "".equals(idSO.getTipo()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Nome Soggetto Proprietario non definito.");

  319.             nome_sa = idServizioApplicativoObject.getNome();
  320.             if(nome_sa==null){
  321.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Nome non definito.");
  322.             }
  323.             type = TYPE_ID_OBJECT;
  324.         }
  325.         else if(apiKey){
  326.             type = TYPE_API_KEY;
  327.         }
  328.         else if(aUser!=null){
  329.             type = TYPE_BASIC;
  330.         }
  331.         else if(aSubject!=null){
  332.             type = TYPE_SSL_SUBJECT_ISSUER;
  333.         }
  334.         else if(aCertificate!=null){
  335.             type = TYPE_SSL_CERTIFICATE;
  336.         }
  337.         else if(principal!=null){
  338.             type = TYPE_PRINCIPAL;
  339.         }
  340.         else if(tokenPolicy!=null){
  341.             type = TYPE_TOKEN;
  342.         }
  343.         else{
  344.             type = TYPE_ID_LONG;
  345.             if(idServizioApplicativo==null || idServizioApplicativo.longValue()<=0){
  346.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Id DB non definito.");
  347.             }
  348.         }

  350.         if (this.driver.atomica) {
  351.             try {
  352.                 con = this.driver.getConnectionFromDatasource("getServizioApplicativo");

  354.             } catch (Exception e) {
  355.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Exception accedendo al datasource :" + e.getMessage(),e);

  357.             }

  359.         } else
  360.             con = this.driver.globalConnection;

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

  364.         try {

  366.             switch (type) {
  367.             case TYPE_ID_OBJECT:{
  368.                 String tipoSog=idServizioApplicativoObject.getIdSoggettoProprietario().getTipo();
  369.                 String nomeSog=idServizioApplicativoObject.getIdSoggettoProprietario().getNome();

  371.                 long idSog=DBUtils.getIdSoggetto(nomeSog, tipoSog, con, this.driver.tipoDB,this.driver.tabellaSoggetti);

  373.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  374.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  375.                 sqlQueryObject.addSelectField("*");
  376.                 sqlQueryObject.addWhereCondition("nome = ?");
  377.                 sqlQueryObject.addWhereCondition("id_soggetto = ?");
  378.                 sqlQueryObject.setANDLogicOperator(true);
  379.                 sqlQuery = sqlQueryObject.createSQLQuery();
  380.                 stm = con.prepareStatement(sqlQuery);
  381.                 stm.setString(1, nome_sa);
  382.                 stm.setLong(2, idSog);
  383.                 this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, nome_sa));

  385.                 break;
  386.             }
  387.             case TYPE_BASIC:
  388.             case TYPE_API_KEY:{

  390.                 boolean testInChiaro = false;
  391.                 ICrypt crypt = null;
  392.                 String tipoCredenziale = null;
  393.                 if(type==TYPE_BASIC) {
  394.                     tipoCredenziale = CostantiConfigurazione.CREDENZIALE_BASIC.toString();
  395.                     if(config==null || config.isBackwardCompatibility()) {
  396.                         testInChiaro = true;
  397.                     }
  398.                     if(config!=null) {
  399.                         crypt = CryptFactory.getCrypt(this.driver.log, config);
  400.                     }
  401.                 }
  402.                 else {
  403.                     tipoCredenziale = CostantiConfigurazione.CREDENZIALE_APIKEY.toString();
  404.                     if(config!=null) {
  405.                         crypt = CryptFactory.getCrypt(this.driver.log, config);
  406.                     }
  407.                     else {
  408.                         testInChiaro = true;
  409.                     }
  410.                 }
  411.                 
  412.                 //cerco un servizio applicativo che contenga utente e password con autenticazione basi
  413.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  414.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  415.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  416.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  417.                 }
  418.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI+".id","saId");
  419.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI+".password","saPwd");
  420.                 sqlQueryObject.addWhereCondition("tipoauth = ?");
  421.                 sqlQueryObject.addWhereCondition("utente = ?");
  422.                 if(apiKey) {
  423.                     sqlQueryObject.addWhereCondition("issuer = ?");
  424.                 }
  425.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  426.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  427.                     sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  428.                 }
  429.                 sqlQueryObject.setANDLogicOperator(true);
  430.                 sqlQuery = sqlQueryObject.createSQLQuery();
  431.                 stm = con.prepareStatement(sqlQuery);
  432.                 stm.setString(1, tipoCredenziale);
  433.                 stm.setString(2, aUser);
  434.                 if(apiKey) {
  435.                     stm.setString(3, CostantiDB.getIssuerApiKey(appId));
  436.                 }

  438.                 if(apiKey) {
  439.                     this.driver.logDebug("eseguo query :" + DBUtils.formatSQLString(sqlQuery, tipoCredenziale, aUser, CostantiDB.getIssuerApiKey(appId)));
  440.                 }
  441.                 else {
  442.                     this.driver.logDebug("eseguo query :" + DBUtils.formatSQLString(sqlQuery, tipoCredenziale, aUser));
  443.                 }

  445.                 rs = stm.executeQuery();
  446.                 long idSA = -1;
  447.                 while(rs.next()){
  448.                     
  449.                     String passwordDB =  rs.getString("saPwd");
  450.                     
  451.                     boolean found = false;
  452.                     if(testInChiaro) {
  453.                         found = aPassord.equals(passwordDB);
  454.                     }
  455.                     if(!found && crypt!=null) {
  456.                         found = crypt.check(aPassord, passwordDB);
  457.                     }
  458.                     
  459.                     if( found ) {
  460.                         idSA = rs.getLong("saId");
  461.                         break;
  462.                     }

  464.                 }
  465.                 rs.close();
  466.                 stm.close();
  467.                 /**System.out.println("TROVATO["+idSA+"]");*/
  468.                 if(idSA<=0){
  469.                     throw new DriverConfigurazioneNotFound("Nessun Servizio Applicativo trovato.");
  470.                 }
  471.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  472.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  473.                 sqlQueryObject.addSelectField("*");
  474.                 sqlQueryObject.addWhereCondition("id = ?");
  475.                 stm = con.prepareStatement(sqlQueryObject.toString());
  476.                 stm.setLong(1, idSA);

  478.                 this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, idSA));
  479.                 
  480.                 break;
  481.             }   
  482.             case TYPE_SSL_SUBJECT_ISSUER:{

  484.                 // Autenticazione SSL deve essere LIKE
  485.                 Map<String, List<String>> hashSubject = CertificateUtils.getPrincipalIntoMap(aSubject, PrincipalType.SUBJECT);
  486.                 Map<String, List<String>> hashIssuer = null;
  487.                 if(StringUtils.isNotEmpty(aIssuer)) {
  488.                     hashIssuer = CertificateUtils.getPrincipalIntoMap(aIssuer, PrincipalType.ISSUER);
  489.                 }

  491.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  492.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  493.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  494.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  495.                 }
  496.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "saIdentificativo");
  497.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "subject", "saSubject");
  498.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "issuer", "saIssuer");
  499.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "tipoauth", "saTipoAuth");
  500.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?");
  501.                 // I certificati caricati con una token policy potrebbero non dover essere considerati per l'autenticazione https
  502.                 // in futuro se serve gestire il boolean tokenWithHttpsEnabled anche per l'autenticazione https
  503.                 if(!tokenWithHttpsEnabled){
  504.                     sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy");
  505.                 }

  507.                 for (String key : hashSubject.keySet()) {
  508.                     List<String> listValues = hashSubject.get(key);
  509.                     for (String value : listValues) {
  510.                         sqlQueryObject.addWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI+".subject", "/"+CertificateUtils.formatKeyPrincipal(key)+"="+CertificateUtils.formatValuePrincipal(value)+"/", true, true, false);
  511.                     }
  512.                 }
  513.                 
  514.                 if(hashIssuer!=null) {
  515.                     for (String key : hashIssuer.keySet()) {            
  516.                         List<String> listValues = hashIssuer.get(key);
  517.                         for (String value : listValues) {
  518.                             sqlQueryObject.addWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI+".issuer", "/"+CertificateUtils.formatKeyPrincipal(key)+"="+CertificateUtils.formatValuePrincipal(value)+"/", true, true, false);
  519.                         }
  520.                     }
  521.                 }
  522.                 else {
  523.                     sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI+".issuer");
  524.                 }
  525.                 
  526.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  527.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  528.                     
  529.                     if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  530.                         ISQLQueryObject object =  buildFiltroApplicativiTls(sqlQueryObject, tipiSoggetto,
  531.                                 includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  532.                         sqlQueryObject.addWhereCondition(object.createSQLConditions());
  533.                     } else {
  534.                         sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  535.                     }
  536.                 }

  538.                 sqlQueryObject.setANDLogicOperator(true);
  539.                 sqlQuery = sqlQueryObject.createSQLQuery();

  541.                 //System.out.println("QUERY["+sqlQuery+"]["+type+"]["+idSoggettoFruitore+"]["+CostantiConfigurazione.CREDENZIALE_SSL.toString()+"]");

  543.                 stm = con.prepareStatement(sqlQuery);
  544.                 stm.setString(1, CostantiConfigurazione.CREDENZIALE_SSL.toString());

  546.                 this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, CostantiConfigurazione.CREDENZIALE_SSL.toString()));

  548.                 rs = stm.executeQuery();
  549.                 long idSA = -1;
  550.                 while(rs.next()){
  551.                     // Possono esistere piu' sil che hanno una porzione di subject uguale, devo quindi verificare che sia proprio quello che cerco
  552.                     
  553.                     String subjectPotenziale =  rs.getString("saSubject");
  554.                     boolean subjectValid = CertificateUtils.sslVerify(subjectPotenziale, aSubject, PrincipalType.SUBJECT, this.driver.log);
  555.                     
  556.                     boolean issuerValid = true;
  557.                     if(hashIssuer!=null) {
  558.                         String issuerPotenziale =  rs.getString("saIssuer");
  559.                         if(StringUtils.isNotEmpty(issuerPotenziale)) {
  560.                             issuerValid = CertificateUtils.sslVerify(issuerPotenziale, aIssuer, PrincipalType.ISSUER, this.driver.log);
  561.                         }
  562.                         else {
  563.                             issuerValid = false;
  564.                         }
  565.                     }
  566.                     
  567.                     
  568.                     if( subjectValid && issuerValid ) {
  569.                         idSA = rs.getLong("saIdentificativo");
  570.                         break;
  571.                     }
  572.                 }
  573.                 rs.close();
  574.                 stm.close();
  575.                 //System.out.println("TROVATO["+idSA+"]");
  576.                 
  577.                 if(idSA<=0) {
  578.                     // provo a vedere all'interno delle credenziali ulteriori
  579.                     
  580.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  581.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  582.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  583.                     if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  584.                         sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  585.                     }
  586.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "saIdentificativo");
  587.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI, "subject", "saSubject");
  588.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI, "issuer", "saIssuer");
  589.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "tipoauth", "saTipoAuth");
  590.                     sqlQueryObject.setANDLogicOperator(true);
  591.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".id_servizio_applicativo="+CostantiDB.SERVIZI_APPLICATIVI+".id");
  592.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?");
  593.                     // I certificati caricati con una token policy potrebbero non dover essere considerati per l'autenticazione https
  594.                     // in futuro se serve gestire il boolean tokenWithHttpsEnabled anche per l'autenticazione https
  595.                     if(!tokenWithHttpsEnabled){
  596.                         sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy");
  597.                     }
  598.                     
  599.                     for (String key : hashSubject.keySet()) {
  600.                         List<String> listValues = hashSubject.get(key);
  601.                         for (String value : listValues) {
  602.                             sqlQueryObject.addWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".subject", "/"+CertificateUtils.formatKeyPrincipal(key)+"="+CertificateUtils.formatValuePrincipal(value)+"/", true, true, false);
  603.                         }
  604.                     }
  605.                     
  606.                     if(hashIssuer!=null) {
  607.                         for (String key : hashIssuer.keySet()) {
  608.                             List<String> listValues = hashIssuer.get(key);
  609.                             for (String value : listValues) {
  610.                                 sqlQueryObject.addWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".issuer", "/"+CertificateUtils.formatKeyPrincipal(key)+"="+CertificateUtils.formatValuePrincipal(value)+"/", true, true, false);
  611.                             }
  612.                         }
  613.                     }
  614.                     else {
  615.                         sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".issuer");
  616.                     }
  617.                     
  618.                     if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  619.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  620.                         if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  621.                             ISQLQueryObject object =  buildFiltroApplicativiTls(sqlQueryObject, tipiSoggetto,
  622.                                     includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  623.                             sqlQueryObject.addWhereCondition(object.createSQLConditions());
  624.                         } else {
  625.                             sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  626.                         }
  627.                     }

  629.                     sqlQueryObject.setANDLogicOperator(true);
  630.                     sqlQuery = sqlQueryObject.createSQLQuery();
  631.                     
  632.                     //System.out.println("QUERY["+sqlQuery+"]["+type+"]["+idSoggettoFruitore+"]["+CostantiConfigurazione.CREDENZIALE_SSL.toString()+"]");

  634.                     stm = con.prepareStatement(sqlQuery);
  635.                     stm.setString(1, CostantiConfigurazione.CREDENZIALE_SSL.toString());

  637.                     this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, CostantiConfigurazione.CREDENZIALE_SSL.toString()));

  639.                     rs = stm.executeQuery();
  640.                     while(rs.next()){
  641.                         // Possono esistere piu' sil che hanno una porzione di subject uguale, devo quindi verificare che sia proprio quello che cerco
  642.                         
  643.                         String subjectPotenziale =  rs.getString("saSubject");
  644.                         boolean subjectValid = CertificateUtils.sslVerify(subjectPotenziale, aSubject, PrincipalType.SUBJECT, this.driver.log);
  645.                         
  646.                         boolean issuerValid = true;
  647.                         if(hashIssuer!=null) {
  648.                             String issuerPotenziale =  rs.getString("saIssuer");
  649.                             if(StringUtils.isNotEmpty(issuerPotenziale)) {
  650.                                 issuerValid = CertificateUtils.sslVerify(issuerPotenziale, aIssuer, PrincipalType.ISSUER, this.driver.log);
  651.                             }
  652.                             else {
  653.                                 issuerValid = false;
  654.                             }
  655.                         }
  656.                         
  657.                         
  658.                         if( subjectValid && issuerValid ) {
  659.                             idSA = rs.getLong("saIdentificativo");
  660.                             break;
  661.                         }
  662.                     }
  663.                     rs.close();
  664.                     stm.close();
  665.                     //System.out.println("TROVATO["+idSA+"]");
  666.                 }
  667.                 
  668.                 if(idSA<=0){
  669.                     throw new DriverConfigurazioneNotFound("Nessun Servizio Applicativo trovato.");
  670.                 }
  671.                 
  672.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  673.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  674.                 sqlQueryObject.addSelectField("*");
  675.                 sqlQueryObject.addWhereCondition("id = ?");
  676.                 stm = con.prepareStatement(sqlQueryObject.toString());
  677.                 stm.setLong(1, idSA);

  679.                 this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, idSA));

  681.                 break;
  682.             }
  683.             case TYPE_SSL_CERTIFICATE:{

  685.                 String cnSubject = aCertificate.getSubject().getCN();
  686.                 String cnIssuer = aCertificate.getIssuer().getCN();

  688.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  689.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  690.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  691.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  692.                 }
  693.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "saIdentificativo");
  694.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "cn_subject", "saCNSubject");
  695.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "cn_issuer", "saCNIssuer");
  696.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "cert_strict_verification", "saCertStrictVerificationr");
  697.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "certificate", "saCertificate");
  698.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "tipoauth", "saTipoAuth");
  699.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?");
  700.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".cn_subject = ?");
  701.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".cn_issuer = ?");
  702.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".cert_strict_verification = ?");
  703.                 // I certificati caricati con una token policy potrebbero non dover essere considerati per l'autenticazione https
  704.                 // in futuro se serve gestire il boolean tokenWithHttpsEnabled anche per l'autenticazione https
  705.                 if(!tokenWithHttpsEnabled){
  706.                     sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy");
  707.                 }
  708.                 
  709.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  710.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  711.                     if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  712.                         ISQLQueryObject object =  buildFiltroApplicativiTls(sqlQueryObject, tipiSoggetto,
  713.                                 includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  714.                         sqlQueryObject.addWhereCondition(object.createSQLConditions());
  715.                     } else {
  716.                         sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  717.                     }
  718.                 }

  720.                 sqlQueryObject.setANDLogicOperator(true);
  721.                 sqlQuery = sqlQueryObject.createSQLQuery();

  723.                 //System.out.println("QUERY["+sqlQuery+"]["+type+"]["+idSoggettoFruitore+"]["+CostantiConfigurazione.CREDENZIALE_SSL.toString()+"]");

  725.                 stm = con.prepareStatement(sqlQuery);
  726.                 int index = 1;
  727.                 stm.setString(index++, CostantiConfigurazione.CREDENZIALE_SSL.toString());
  728.                 stm.setString(index++, cnSubject);
  729.                 stm.setString(index++, cnIssuer);
  730.                 if(aStrictVerifier) {
  731.                     stm.setInt(index++, CostantiDB.TRUE);
  732.                 }
  733.                 else {
  734.                     stm.setInt(index++, CostantiDB.FALSE);
  735.                 }

  737.                 this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, CostantiConfigurazione.CREDENZIALE_SSL.toString()));

  739.                 IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  740.                 
  741.                 rs = stm.executeQuery();
  742.                 long idSA = -1;
  743.                 while(rs.next()){
  744.                     // Possono esistere piu' sil che hanno un CN con subject e issuer diverso.
  745.                     
  746.                     byte[] certificatoBytes = jdbcAdapter.getBinaryData(rs, "saCertificate");
  747.                     Certificate certificato = ArchiveLoader.load(ArchiveType.CER, certificatoBytes, 0, null);
  748.                     //int tmpStrict = rs.getInt("cert_strict_verification");
  749.                     //boolean strict = tmpStrict == CostantiDB.TRUE;
  750.                     
  751.                     if(aCertificate.equals(certificato.getCertificate(),aStrictVerifier)) {
  752.                         idSA = rs.getLong("saIdentificativo");
  753.                         break;
  754.                     }

  756.                 }
  757.                 rs.close();
  758.                 stm.close();
  759.                 //System.out.println("TROVATO["+idSA+"]");
  760.                 
  761.                 if(idSA<=0) {
  762.                     // provo a vedere all'interno delle credenziali ulteriori
  763.                     
  764.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  765.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  766.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  767.                     if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  768.                         sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  769.                     }
  770.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "saIdentificativo");
  771.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI, "cn_subject", "saCNSubject");
  772.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI, "cn_issuer", "saCNIssuer");
  773.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI, "cert_strict_verification", "saCertStrictVerificationr");
  774.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI, "certificate", "saCertificate");
  775.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "tipoauth", "saTipoAuth");
  776.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".id_servizio_applicativo="+CostantiDB.SERVIZI_APPLICATIVI+".id");
  777.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?");
  778.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".cn_subject = ?");
  779.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".cn_issuer = ?");
  780.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".cert_strict_verification = ?");
  781.                     // I certificati caricati con una token policy potrebbero non dover essere considerati per l'autenticazione https
  782.                     // in futuro se serve gestire il boolean tokenWithHttpsEnabled anche per l'autenticazione https
  783.                     if(!tokenWithHttpsEnabled){
  784.                         sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy");
  785.                     }
  786.                     
  787.                     if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  788.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  789.                         if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  790.                             ISQLQueryObject object =  buildFiltroApplicativiTls(sqlQueryObject, tipiSoggetto,
  791.                                     includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  792.                             sqlQueryObject.addWhereCondition(object.createSQLConditions());
  793.                         } else {
  794.                             sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  795.                         }
  796.                     }
  797.                     
  798.                     sqlQueryObject.setANDLogicOperator(true);
  799.                     sqlQuery = sqlQueryObject.createSQLQuery();

  801.                     //System.out.println("QUERY["+sqlQuery+"]["+type+"]["+idSoggettoFruitore+"]["+CostantiConfigurazione.CREDENZIALE_SSL.toString()+"]");

  803.                     stm = con.prepareStatement(sqlQuery);
  804.                     index = 1;
  805.                     stm.setString(index++, CostantiConfigurazione.CREDENZIALE_SSL.toString());
  806.                     stm.setString(index++, cnSubject);
  807.                     stm.setString(index++, cnIssuer);
  808.                     if(aStrictVerifier) {
  809.                         stm.setInt(index++, CostantiDB.TRUE);
  810.                     }
  811.                     else {
  812.                         stm.setInt(index++, CostantiDB.FALSE);
  813.                     }

  815.                     this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, CostantiConfigurazione.CREDENZIALE_SSL.toString()));

  817.                     jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  818.                     
  819.                     rs = stm.executeQuery();
  820.                     while(rs.next()){
  821.                         // Possono esistere piu' sil che hanno un CN con subject e issuer diverso.
  822.                         
  823.                         byte[] certificatoBytes = jdbcAdapter.getBinaryData(rs, "saCertificate");
  824.                         Certificate certificato = ArchiveLoader.load(ArchiveType.CER, certificatoBytes, 0, null);
  825.                         //int tmpStrict = rs.getInt("cert_strict_verification");
  826.                         //boolean strict = tmpStrict == CostantiDB.TRUE;
  827.                         
  828.                         if(aCertificate.equals(certificato.getCertificate(),aStrictVerifier)) {
  829.                             idSA = rs.getLong("saIdentificativo");
  830.                             break;
  831.                         }

  833.                     }
  834.                     rs.close();
  835.                     stm.close();
  836.                     //System.out.println("TROVATO["+idSA+"]");
  837.                 }
  838.                 
  839.                 if(idSA<=0){
  840.                     throw new DriverConfigurazioneNotFound("Nessun Servizio Applicativo trovato.");
  841.                 }
  842.                 
  843.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  844.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  845.                 sqlQueryObject.addSelectField("*");
  846.                 sqlQueryObject.addWhereCondition("id = ?");
  847.                 stm = con.prepareStatement(sqlQueryObject.toString());
  848.                 stm.setLong(1, idSA);

  850.                 this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, idSA));

  852.                 break;
  853.             }   
  854.             case TYPE_PRINCIPAL:{

  856.                 //cerco un servizio applicativo che contenga utente e password con autenticazione basi
  857.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  858.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  859.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  860.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  861.                 }
  862.                 sqlQueryObject.addSelectField("*");
  863.                 sqlQueryObject.addWhereCondition("tipoauth = ?");
  864.                 sqlQueryObject.addWhereCondition("utente = ?");
  865.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  866.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  867.                     sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  868.                 }
  869.                 sqlQueryObject.setANDLogicOperator(true);
  870.                 sqlQuery = sqlQueryObject.createSQLQuery();
  871.                 stm = con.prepareStatement(sqlQuery);
  872.                 //stm.setString(1, nome_sa);
  873.                 stm.setString(1, CostantiConfigurazione.CREDENZIALE_PRINCIPAL.toString());
  874.                 stm.setString(2, principal);
  875.                 this.driver.logDebug("eseguo query :" + DBUtils.formatSQLString(sqlQuery, CostantiConfigurazione.CREDENZIALE_PRINCIPAL.toString(), principal));

  877.                 break;
  878.             }
  879.             case TYPE_TOKEN:{

  881.                 //cerco un servizio applicativo che contenga l'autenticazione token
  882.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  883.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  884.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  885.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  886.                 }
  887.                 sqlQueryObject.addSelectField("*");
  888.                 
  889.                 List<FiltroRicercaProtocolPropertyConfig> modiFilter = null; 
  890.                 if(tokenWithHttpsEnabled){
  891.                 
  892.                     modiFilter = buildListModiTokenCredentials(tokenPolicy, tokenClientId);
  893.                     
  894.                     ISQLQueryObject sqlQueryObjectBuiltIn = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  895.                     sqlQueryObjectBuiltIn.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  896.                     sqlQueryObjectBuiltIn.addWhereCondition(false, "tipoauth = ?", "tipoauth = ?");
  897.                     sqlQueryObjectBuiltIn.addWhereCondition("token_policy = ?");
  898.                     sqlQueryObjectBuiltIn.addWhereCondition("utente = ?");
  899.                     sqlQueryObjectBuiltIn.setANDLogicOperator(true);
  900.                     
  901.                     ISQLQueryObject sqlQueryObjectModi = buildSQLQueryObjectModiTokenCredentials(modiFilter);
  902.                     
  903.                     sqlQueryObject.addWhereCondition(sqlQueryObjectBuiltIn.createSQLConditions());
  904.                     sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectModi);
  905.                     sqlQueryObject.setANDLogicOperator(false);
  906.                 }
  907.                 else {
  908.                     sqlQueryObject.addWhereCondition("tipoauth = ?");
  909.                     sqlQueryObject.addWhereCondition("token_policy = ?");
  910.                     sqlQueryObject.addWhereCondition("utente = ?");
  911.                     sqlQueryObject.setANDLogicOperator(true);
  912.                 }
  913.                 
  914.                 if(tipiSoggetto!=null && !tipiSoggetto.isEmpty()) {
  915.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  916.                     sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  917.                 }

  919.                 sqlQuery = sqlQueryObject.createSQLQuery();
  920.                 stm = con.prepareStatement(sqlQuery);
  921.                 
  922.                 int index = 1;
  923.                 if(tokenWithHttpsEnabled){
  924.                     stm.setString(index++, CostantiConfigurazione.CREDENZIALE_TOKEN.toString());
  925.                     stm.setString(index++, CostantiConfigurazione.CREDENZIALE_SSL.toString());
  926.                     stm.setString(index++, tokenPolicy);
  927.                     stm.setString(index++, tokenClientId);
  928.                     setSQLQueryObjectModiTokenCredentials (stm, index, modiFilter);
  929.                 }
  930.                 else {
  931.                     stm.setString(index++, CostantiConfigurazione.CREDENZIALE_TOKEN.toString());
  932.                     stm.setString(index++, tokenPolicy);
  933.                     stm.setString(index++, tokenClientId);
  934.                 }
  935.                 
  936.                 this.driver.logDebug("eseguo query (tokenPolicy:"+tokenPolicy+" tokenClientId:"+tokenClientId+"):" +sqlQuery);

  938.                 break;
  939.             }
  940.             case TYPE_ID_LONG:{
  941.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  942.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  943.                 sqlQueryObject.addSelectField("*");
  944.                 sqlQueryObject.addWhereCondition("id = ?");
  945.                 sqlQuery = sqlQueryObject.createSQLQuery();
  946.                 stm = con.prepareStatement(sqlQuery);
  947.                 stm.setLong(1, idServizioApplicativo);

  949.                 this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, idServizioApplicativo));
  950.                 break;
  951.             }
  952.             
  953.             }

  955.             if(stm==null) {
  956.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Type '"+type+"' sconosciuto?");
  957.             }
  958.             
  959.             rs = stm.executeQuery();

  961.             if (rs.next()) {
  962.                 sa = new ServizioApplicativo();

  964.                 sa.setId(rs.getLong("id"));
  965.                 sa.setTipo(rs.getString("tipo"));
  966.                 sa.setNome(rs.getString("nome"));
  967.                 sa.setIdSoggetto(rs.getLong("id_soggetto"));
  968.                 //tipo e nome soggetto
  969.                 //tipo e nome soggetto sono necessari per la propagazione...
  970.                 sa.setTipoSoggettoProprietario(this.soggettiDriver.getSoggetto(sa.getIdSoggetto(),con).getTipo());
  971.                 sa.setNomeSoggettoProprietario(this.soggettiDriver.getSoggetto(sa.getIdSoggetto(),con).getNome());
  972.                 // descrizione
  973.                 sa.setDescrizione(rs.getString("descrizione"));

  975.                 int as_client = rs.getInt("as_client");
  976.                 sa.setUseAsClient(CostantiDB.TRUE == as_client);
  977.                 
  978.                 //tipologia fruizione
  979.                 String tipoFruizione = rs.getString("tipologia_fruizione")!=null && !"".equals(rs.getString("tipologia_fruizione")) ? rs.getString("tipologia_fruizione") : TipologiaFruizione.DISABILITATO.toString();
  980.                 String tipoErogazione = rs.getString("tipologia_erogazione")!=null && !"".equals(rs.getString("tipologia_erogazione"))? rs.getString("tipologia_erogazione") : TipologiaErogazione.DISABILITATO.toString();
  981.                 sa.setTipologiaFruizione(TipologiaFruizione.valueOf(tipoFruizione.toUpperCase()).toString());
  982.                 sa.setTipologiaErogazione(TipologiaErogazione.valueOf(tipoErogazione.toUpperCase()).toString());

  984.                 //se le credenziali sono nulle allora non nn esiste invocazione porta
  985.                 InvocazionePorta invPorta = null;
  986.                 String tipoAuth = rs.getString("tipoauth");
  987.                 String fault = rs.getString("fault");
  988.                 String faultActor = rs.getString("fault_actor");
  989.                 String prefixFault = rs.getString("prefix_fault_code");
  990.                 String genericFault = rs.getString("generic_fault_code");
  991.                 if ((tipoAuth != null && !tipoAuth.equals("")) || 
  992.                         (fault != null && !fault.equals("")) ||
  993.                         (faultActor!=null && !faultActor.equals("")) ||
  994.                         (genericFault!=null && !genericFault.equals("")) ||
  995.                         (prefixFault!=null && !prefixFault.equals(""))
  996.                         ) {
  997.                     invPorta = new InvocazionePorta();
  998.                     Credenziali credenziali = new Credenziali();
  999.                     
  1000.                     credenziali.setTipo(DriverConfigurazioneDBLib.getEnumCredenzialeTipo(tipoAuth));
  1001.                     
  1002.                     credenziali.setUser(rs.getString("utente"));
  1003.                     credenziali.setPassword(rs.getString("password"));
  1004.                     
  1005.                     if(org.openspcoop2.core.config.constants.CredenzialeTipo.APIKEY.equals(credenziali.getTipo())) {
  1006.                         credenziali.setAppId(CostantiDB.isAPPID(rs.getString("issuer")));
  1007.                     }
  1008.                     else {
  1009.                         credenziali.setIssuer(rs.getString("issuer"));
  1010.                     }
  1011.                     
  1012.                     credenziali.setSubject(rs.getString("subject"));
  1013.                     credenziali.setCnSubject(rs.getString("cn_subject"));
  1014.                     credenziali.setCnIssuer(rs.getString("cn_issuer"));
  1015.                     IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  1016.                     credenziali.setCertificate(jdbcAdapter.getBinaryData(rs, "certificate"));
  1017.                     int strict = rs.getInt("cert_strict_verification");
  1018.                     if(strict == CostantiDB.TRUE) {
  1019.                         credenziali.setCertificateStrictVerification(true);
  1020.                     }
  1021.                     else if(strict == CostantiDB.FALSE) {
  1022.                         credenziali.setCertificateStrictVerification(false);
  1023.                     }
  1024.                     
  1025.                     credenziali.setTokenPolicy(rs.getString("token_policy"));
  1026.                     
  1027.                     if(tipoAuth != null && !tipoAuth.equals("")){
  1028.                         invPorta.addCredenziali( credenziali );
  1029.                     }

  1031.                     InvocazionePortaGestioneErrore gestioneErrore = new InvocazionePortaGestioneErrore();
  1032.                     gestioneErrore.setFault(DriverConfigurazioneDBLib.getEnumFaultIntegrazioneTipo(fault));
  1033.                     gestioneErrore.setFaultActor(faultActor);
  1034.                     gestioneErrore.setGenericFaultCode(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(genericFault));
  1035.                     gestioneErrore.setPrefixFaultCode(prefixFault);
  1036.                     //setto gestione errore solo se i valori sono diversi da null
  1037.                     invPorta.setGestioneErrore((fault != null || faultActor!=null || genericFault!=null || prefixFault!=null ) ? gestioneErrore : null);

  1039.                     invPorta.setInvioPerRiferimento(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("invio_x_rif")));

  1041.                     int sbustamentoInfoProtocollo = rs.getInt("sbustamento_protocol_info");
  1042.                     if(CostantiDB.TRUE == sbustamentoInfoProtocollo)
  1043.                         invPorta.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.ABILITATO);
  1044.                     else if(CostantiDB.FALSE == sbustamentoInfoProtocollo)
  1045.                         invPorta.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.DISABILITATO);
  1046.                     else
  1047.                         invPorta.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.ABILITATO);
  1048.                     
  1049.                 }

  1051.                 // RispostaAsincrona
  1052.                 //se non esiste il connnettore e getmsgrisp e' disabilitato allora nn esiste risposta asincrona
  1053.                 Long idConnettore = rs.getLong("id_connettore_risp");
  1054.                 String getMsgRisp = rs.getString("getmsgrisp");
  1055.                 RispostaAsincrona rispAsinc = null;             
  1056.                 if (idConnettore > 0 || (getMsgRisp != null && !getMsgRisp.equals("")) ) {
  1057.                     rispAsinc = new RispostaAsincrona();

  1059.                     rispAsinc.setAutenticazione(DriverConfigurazioneDBLib.getEnumInvocazioneServizioTipoAutenticazione(rs.getString("tipoauthrisp")));
  1060.                     rispAsinc.setInvioPerRiferimento(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("invio_x_rif_risp")));
  1061.                     rispAsinc.setRispostaPerRiferimento(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("risposta_x_rif_risp")));

  1063.                     if(rispAsinc.getAutenticazione()!=null && InvocazioneServizioTipoAutenticazione.BASIC.equals(rispAsinc.getAutenticazione())){
  1064.                         InvocazioneCredenziali credenzialiRispA = new InvocazioneCredenziali();
  1065.                         
  1066.                         String encValue = rs.getString("enc_passwordrisp");
  1067.                         String plainValue = rs.getString("passwordrisp");
  1068.                         if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1069.                             IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1070.                             if(driverBYOK!=null) {
  1071.                                 credenzialiRispA.setPassword(driverBYOK.unwrapAsString(encValue));
  1072.                             }
  1073.                             else {
  1074.                                 credenzialiRispA.setPassword(encValue);
  1075.                             }
  1076.                         }
  1077.                         else {
  1078.                             credenzialiRispA.setPassword(plainValue);
  1079.                         }
  1080.                         
  1081.                         credenzialiRispA.setUser(rs.getString("utenterisp"));
  1082.                         rispAsinc.setCredenziali(credenzialiRispA);
  1083.                     }
  1084.                     
  1085.                     Connettore connettore = DriverConfigurazioneDB_connettoriLIB.getConnettore(idConnettore, con, this.driver.getDriverUnwrapBYOK());
  1086.                     rispAsinc.setConnettore(connettore);
  1087.                     rispAsinc.setGetMessage(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(getMsgRisp));

  1089.                     int sbustamentoInfoProtocollo = rs.getInt("sbustamento_protocol_info_risp");
  1090.                     if(CostantiDB.TRUE == sbustamentoInfoProtocollo)
  1091.                         rispAsinc.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.ABILITATO);
  1092.                     else if(CostantiDB.FALSE == sbustamentoInfoProtocollo)
  1093.                         rispAsinc.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.DISABILITATO);
  1094.                     else
  1095.                         rispAsinc.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.ABILITATO);

  1097.                     if(rs.getInt("sbustamentorisp")==1)
  1098.                         rispAsinc.setSbustamentoSoap(CostantiConfigurazione.ABILITATO);
  1099.                     else
  1100.                         rispAsinc.setSbustamentoSoap(CostantiConfigurazione.DISABILITATO);

  1102.                     // Gestione errore
  1103.                     Long idGestioneErroreRispostaAsincrona = rs.getLong("id_gestione_errore_risp");
  1104.                     GestioneErrore gestioneErroreRispostaAsincrona = null;
  1105.                     if(idGestioneErroreRispostaAsincrona>0){
  1106.                         gestioneErroreRispostaAsincrona = DriverConfigurazioneDB_gestioneErroreLIB.getGestioneErrore(idGestioneErroreRispostaAsincrona, con);
  1107.                         rispAsinc.setGestioneErrore(gestioneErroreRispostaAsincrona);
  1108.                     }
  1109.                 }

  1111.                 // InvocazioneServizio
  1112.                 //se non esiste il connettore e getmsginv e' disabilitato allora non esiste invocazione servizio 
  1113.                 idConnettore = rs.getLong("id_connettore_inv");
  1114.                 String getMsgInv = rs.getString("getmsginv");
  1115.                 InvocazioneServizio invServizio = null;             
  1116.                 if (idConnettore > 0 || (getMsgInv != null && !getMsgInv.equals("")) ) {
  1117.                     invServizio = new InvocazioneServizio();
  1118.                     Connettore connserv = DriverConfigurazioneDB_connettoriLIB.getConnettore(idConnettore, con, this.driver.getDriverUnwrapBYOK());
  1119.                     invServizio.setConnettore(connserv);
  1120.                     invServizio.setGetMessage(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(getMsgInv));

  1122.                     int sbustamentoInfoProtocollo = rs.getInt("sbustamento_protocol_info_inv");
  1123.                     if(CostantiDB.TRUE == sbustamentoInfoProtocollo)
  1124.                         invServizio.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.ABILITATO);
  1125.                     else if(CostantiDB.FALSE == sbustamentoInfoProtocollo)
  1126.                         invServizio.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.DISABILITATO);
  1127.                     else
  1128.                         invServizio.setSbustamentoInformazioniProtocollo(CostantiConfigurazione.ABILITATO);

  1130.                     if(rs.getInt("sbustamentoinv")==1)
  1131.                         invServizio.setSbustamentoSoap(CostantiConfigurazione.ABILITATO);
  1132.                     else
  1133.                         invServizio.setSbustamentoSoap(CostantiConfigurazione.DISABILITATO);

  1135.                     invServizio.setAutenticazione(DriverConfigurazioneDBLib.getEnumInvocazioneServizioTipoAutenticazione(rs.getString("tipoauthinv")));
  1136.                     invServizio.setInvioPerRiferimento(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("invio_x_rif_inv")));
  1137.                     invServizio.setRispostaPerRiferimento(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("risposta_x_rif_inv")));
  1138.                     
  1139.                     if(invServizio.getAutenticazione()!=null && InvocazioneServizioTipoAutenticazione.BASIC.equals(invServizio.getAutenticazione())){
  1140.                         InvocazioneCredenziali credInvServ = new InvocazioneCredenziali();
  1141.                         
  1142.                         String encValue = rs.getString("enc_passwordinv");
  1143.                         String plainValue = rs.getString("passwordinv");
  1144.                         if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1145.                             IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1146.                             if(driverBYOK!=null) {
  1147.                                 credInvServ.setPassword(driverBYOK.unwrapAsString(encValue));
  1148.                             }
  1149.                             else {
  1150.                                 credInvServ.setPassword(encValue);
  1151.                             }
  1152.                         }
  1153.                         else {
  1154.                             credInvServ.setPassword(plainValue);
  1155.                         }
  1156.                         
  1157.                         credInvServ.setUser(rs.getString("utenteinv"));
  1158.                         invServizio.setCredenziali(credInvServ);
  1159.                     }

  1161.                     // Gestione errore
  1162.                     Long idGestioneErroreInvocazioneServizio = rs.getLong("id_gestione_errore_inv");
  1163.                     GestioneErrore gestioneErroreInvocazioneServizio = null;
  1164.                     if(idGestioneErroreInvocazioneServizio>0){
  1165.                         gestioneErroreInvocazioneServizio = DriverConfigurazioneDB_gestioneErroreLIB.getGestioneErrore(idGestioneErroreInvocazioneServizio, con);
  1166.                         invServizio.setGestioneErrore(gestioneErroreInvocazioneServizio);
  1167.                     }
  1168.                 }

  1170.                 sa.setInvocazionePorta(invPorta);
  1171.                 sa.setRispostaAsincrona(rispAsinc);
  1172.                 sa.setInvocazioneServizio(invServizio);

  1174.                 // retrocompatibilita tipologie
  1175.                 if(sa.getTipologiaErogazione()==null){
  1176.                     sa.setTipologiaErogazione(TipologiaErogazione.DISABILITATO.getValue());
  1177.                 }
  1178.                 if(sa.getTipologiaFruizione()==null){
  1179.                     sa.setTipologiaFruizione(TipologiaFruizione.DISABILITATO.getValue());
  1180.                 }
  1181.                 if(TipologiaErogazione.DISABILITATO.equals(sa.getTipologiaErogazione()) &&
  1182.                         TipologiaFruizione.DISABILITATO.equals(sa.getTipologiaFruizione())){
  1183.                     
  1184.                     // TipologiaFruizione: cerco di comprenderlo dalla configurazione del sa
  1185.                     if(sa.getInvocazionePorta()!=null && sa.getInvocazionePorta().sizeCredenzialiList()>0){
  1186.                         sa.setTipologiaFruizione(TipologiaFruizione.NORMALE.getValue());
  1187.                     }

  1189.                     // TipologiaErogazione: cerco di comprenderlo dalla configurazione del sa
  1190.                     if(sa.getInvocazioneServizio()!=null){
  1191.                         if(StatoFunzionalita.ABILITATO.equals(sa.getInvocazioneServizio().getGetMessage())){
  1192.                             sa.setTipologiaErogazione(TipologiaErogazione.MESSAGE_BOX.getValue());
  1193.                         }
  1194.                         else if(sa.getInvocazioneServizio().getConnettore()!=null && 
  1195.                                 !TipiConnettore.DISABILITATO.getNome().equals(sa.getInvocazioneServizio().getConnettore().getTipo())){
  1196.                             sa.setTipologiaErogazione(TipologiaErogazione.TRASPARENTE.getValue());
  1197.                         }
  1198.                     }
  1199.                         
  1200.                 }   
  1201.                 
  1202.                 // Proprieta Oggetto
  1203.                 sa.setProprietaOggetto(this.utilsDriver.readProprietaOggetto(rs,false));
  1204.                 
  1205.                 rs.close();
  1206.                 stm.close();
  1207.                 
  1208.                 
  1209.                 
  1210.                 // ruoli
  1211.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1212.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  1213.                 sqlQueryObject.addSelectField("*");
  1214.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1215.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1216.                 stm = con.prepareStatement(sqlQuery);
  1217.                 stm.setLong(1, sa.getId());
  1218.                 rs = stm.executeQuery();

  1220.                 while (rs.next()) {
  1221.                     
  1222.                     if(sa.getInvocazionePorta()==null){
  1223.                         sa.setInvocazionePorta(new InvocazionePorta());
  1224.                     }
  1225.                     if(sa.getInvocazionePorta().getRuoli()==null){
  1226.                         sa.getInvocazionePorta().setRuoli(new ServizioApplicativoRuoli());
  1227.                     }
  1228.                     
  1229.                     Ruolo ruolo = new Ruolo();
  1230.                     ruolo.setNome(rs.getString("ruolo"));
  1231.                     sa.getInvocazionePorta().getRuoli().addRuolo(ruolo);
  1232.                 
  1233.                 }
  1234.                 rs.close();
  1235.                 stm.close();
  1236.                 
  1237.                 
  1238.                 // credenziali
  1239.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1240.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  1241.                 sqlQueryObject.addSelectField("*");
  1242.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1243.                 sqlQueryObject.addOrderBy("id", true);
  1244.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1245.                 stm = con.prepareStatement(sqlQuery);
  1246.                 stm.setLong(1, sa.getId());
  1247.                 rs = stm.executeQuery();

  1249.                 while (rs.next()) {
  1250.                     
  1251.                     if(sa.getInvocazionePorta()==null){
  1252.                         sa.setInvocazionePorta(new InvocazionePorta());
  1253.                     }
  1254.                     
  1255.                     Credenziali credenziali = new Credenziali();
  1256.                     
  1257.                     credenziali.setTipo(DriverConfigurazioneDBLib.getEnumCredenzialeTipo(tipoAuth));
  1258.                                         
  1259.                     credenziali.setIssuer(rs.getString("issuer"));
  1260.                     credenziali.setSubject(rs.getString("subject"));
  1261.                     credenziali.setCnSubject(rs.getString("cn_subject"));
  1262.                     credenziali.setCnIssuer(rs.getString("cn_issuer"));
  1263.                     IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  1264.                     credenziali.setCertificate(jdbcAdapter.getBinaryData(rs, "certificate"));
  1265.                     int strict = rs.getInt("cert_strict_verification");
  1266.                     if(strict == CostantiDB.TRUE) {
  1267.                         credenziali.setCertificateStrictVerification(true);
  1268.                     }
  1269.                     else if(strict == CostantiDB.FALSE) {
  1270.                         credenziali.setCertificateStrictVerification(false);
  1271.                     }
  1272.                 
  1273.                     sa.getInvocazionePorta().addCredenziali(credenziali);   
  1274.                 }
  1275.                 rs.close();
  1276.                 stm.close();
  1277.                 
  1278.                 
  1279.                 // proprieta'
  1280.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1281.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_PROPS);
  1282.                 sqlQueryObject.addSelectField("*");
  1283.                 sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  1284.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1285.                 stm = con.prepareStatement(sqlQuery);
  1286.                 stm.setLong(1, sa.getId());
  1287.                 rs = stm.executeQuery();

  1289.                 while (rs.next()) {
  1290.                     
  1291.                     Proprieta proprieta = new Proprieta();
  1292.                     proprieta.setNome(rs.getString("nome"));
  1293.                     
  1294.                     String plainValue = rs.getString("valore");
  1295.                     String encValue = rs.getString("enc_value");
  1296.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1297.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1298.                         if(driverBYOK!=null) {
  1299.                             proprieta.setValore(driverBYOK.unwrapAsString(encValue));
  1300.                         }
  1301.                         else {
  1302.                             proprieta.setValore(encValue);
  1303.                         }
  1304.                     }
  1305.                     else {
  1306.                         proprieta.setValore(plainValue);
  1307.                     }
  1308.                     
  1309.                     sa.addProprieta(proprieta);
  1310.                 
  1311.                 }
  1312.                 rs.close();
  1313.                 stm.close();
  1314.                 
  1315.                 
  1316.                 // Protocol Properties
  1317.                 try{
  1318.                     List<ProtocolProperty> listPP = DriverConfigurazioneDBLib.getListaProtocolProperty(sa.getId(), ProprietariProtocolProperty.SERVIZIO_APPLICATIVO, con, 
  1319.                             this.driver.tipoDB, this.driver.getDriverUnwrapBYOK());
  1320.                     if(listPP!=null && !listPP.isEmpty()){
  1321.                         for (ProtocolProperty protocolProperty : listPP) {
  1322.                             sa.addProtocolProperty(protocolProperty);
  1323.                         }
  1324.                     }
  1325.                 }catch(DriverConfigurazioneNotFound dNotFound){
  1326.                     // ignore
  1327.                 }
  1328.                 
  1329.                 
  1330.                 return sa;

  1332.             } else {
  1333.                 throw new DriverConfigurazioneNotFound("Nessun Servizio Applicativo trovato.");
  1334.             }
  1335.         } catch (SQLException e) {
  1336.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] SQLException :" + e.getMessage(),e);
  1337.         }catch (DriverConfigurazioneNotFound e) {
  1338.             throw new DriverConfigurazioneNotFound(e);
  1339.         }catch (Exception e) {
  1340.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Exception :" + e.getMessage(),e);
  1341.         } finally {
  1342.             //Chiudo statement and resultset
  1343.             JDBCUtilities.closeResources(rs, stm);
  1344.             this.driver.closeConnection(con);
  1345.         }

  1347.     }

  1349.     private List<FiltroRicercaProtocolPropertyConfig> buildListModiTokenCredentials (String tokenPolicy, String tokenClientId) throws SQLQueryObjectException {
  1350.         List<FiltroRicercaProtocolPropertyConfig> list = new ArrayList<FiltroRicercaProtocolPropertyConfig>();
  1351.         FiltroRicercaProtocolPropertyConfig pTokenPolicy = new FiltroRicercaProtocolPropertyConfig();
  1352.         pTokenPolicy.setName(CostantiDB.MODIPA_SICUREZZA_TOKEN_POLICY);
  1353.         pTokenPolicy.setValueAsString(tokenPolicy);
  1354.         list.add(pTokenPolicy);
  1355.         FiltroRicercaProtocolPropertyConfig pTokenClientId = new FiltroRicercaProtocolPropertyConfig();
  1356.         pTokenClientId.setName(CostantiDB.MODIPA_SICUREZZA_TOKEN_CLIENT_ID);
  1357.         pTokenClientId.setValueAsString(tokenClientId);
  1358.         list.add(pTokenClientId);
  1359.         return list;
  1360.     }
  1361.     private ISQLQueryObject buildSQLQueryObjectModiTokenCredentials (List<FiltroRicercaProtocolPropertyConfig> list) throws SQLQueryObjectException {
  1362.         ISQLQueryObject sqlQueryObjectProtocolProperties = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1363.         this.protocolPropertiesDriver._setProtocolPropertiesForSearch(sqlQueryObjectProtocolProperties, list, CostantiDB.SERVIZI_APPLICATIVI);
  1364.         return sqlQueryObjectProtocolProperties;
  1365.     }
  1366.     private void setSQLQueryObjectModiTokenCredentials (PreparedStatement stmt, int index,
  1367.             List<FiltroRicercaProtocolPropertyConfig> list) throws SQLQueryObjectException, SQLException, JDBCAdapterException, UtilsException {
  1368.         this.protocolPropertiesDriver._setProtocolPropertiesForSearch(stmt, index, 
  1369.                 list, ProprietariProtocolProperty.SERVIZIO_APPLICATIVO);
  1370.     }
  1371.     
  1372.     private ISQLQueryObject buildFiltroApplicativiTls(ISQLQueryObject sqlQueryObject, List<String> tipiSoggetto,
  1373.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws SQLQueryObjectException {
  1374.         ISQLQueryObject object = null;
  1375.         if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  1376.             object = sqlQueryObject.newSQLQueryObject();
  1377.             object.setANDLogicOperator(false);
  1378.             if(includiApplicativiNonModI) {
  1379.                 ISQLQueryObject notModI = sqlQueryObject.newSQLQueryObject();
  1380.                 notModI.setANDLogicOperator(true);
  1381.                 notModI.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  1382.                 notModI.setNOTBeforeConditions(true);
  1383.                 object.addWhereCondition(notModI.createSQLConditions());
  1384.             }
  1385.             
  1386.             ISQLQueryObject modIEsterniPdd = null;
  1387.             if(includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  1388.                 modIEsterniPdd = sqlQueryObject.newSQLQueryObject();
  1389.                 modIEsterniPdd.addFromTable(CostantiDB.SOGGETTI); // di servizio, non viene usata in createSQLConditions
  1390.                 modIEsterniPdd.setANDLogicOperator(false);
  1391.                 
  1392.                 modIEsterniPdd.addWhereIsNullCondition(CostantiDB.SOGGETTI+".server");
  1393.                 
  1394.                 if(!TipiDatabase.ORACLE.toString().equals(sqlQueryObject.getTipoDatabase())) {
  1395.                     modIEsterniPdd.addWhereIsEmptyCondition(CostantiDB.SOGGETTI+".server");
  1396.                 }
  1397.                 
  1398.                 ISQLQueryObject modIEsterniPddQuery = sqlQueryObject.newSQLQueryObject();
  1399.                 modIEsterniPddQuery.addFromTable(CostantiDB.PDD);
  1400.                 modIEsterniPddQuery.setANDLogicOperator(true);
  1401.                 modIEsterniPddQuery.addSelectAliasField(CostantiDB.PDD, "nome", "nomeServer");
  1402.                 modIEsterniPddQuery.addWhereCondition(CostantiDB.SOGGETTI+".server="+CostantiDB.PDD+".nome");
  1403.                 modIEsterniPddQuery.addWhereCondition(CostantiDB.PDD+".tipo='esterno'");
  1404.                 modIEsterniPdd.addWhereExistsCondition(false, modIEsterniPddQuery);
  1405.                 
  1406.                 modIEsterniPdd.setNOTBeforeConditions(!includiApplicativiModIEsterni);
  1407.                 
  1408.                 ISQLQueryObject modIEsterniP= sqlQueryObject.newSQLQueryObject();
  1409.                 modIEsterniP.setANDLogicOperator(true);
  1410.                 modIEsterniP.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  1411.                 modIEsterniP.addWhereCondition(modIEsterniPdd.createSQLConditions());
  1412.                 object.addWhereCondition(modIEsterniP.createSQLConditions());
  1413.             }
  1414.         }
  1415.         return object;
  1416.     }
  1417.     
  1418.     /**
  1419.      * 
  1420.      * @param aSA
  1421.      * @throws DriverConfigurazioneException
  1422.      */
  1423.     protected void createServizioApplicativo(ServizioApplicativo aSA) throws DriverConfigurazioneException {

  1425.         if (aSA == null)
  1426.             throw new DriverConfigurazioneException("Servizio Applicativo non valido");
  1427.         if (aSA.getNome() == null || aSA.getNome().equals(""))
  1428.             throw new DriverConfigurazioneException("Nome Servizio Applicativo non valido");
  1429.         if (aSA.getNomeSoggettoProprietario() == null || aSA.getNomeSoggettoProprietario().equals(""))
  1430.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Servizio Applicativo non valido");
  1431.         if (aSA.getTipoSoggettoProprietario() == null || aSA.getTipoSoggettoProprietario().equals(""))
  1432.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Servizio Applicativo non valido");

  1434.         Connection con = null;
  1435.         boolean error = false;

  1437.         if (this.driver.atomica) {
  1438.             try {
  1439.                 con = this.driver.getConnectionFromDatasource("createServizioApplicativo");
  1440.                 con.setAutoCommit(false);
  1441.             } catch (Exception e) {
  1442.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createServizioApplicativo] Exception accedendo al datasource :" + e.getMessage(),e);

  1444.             }

  1446.         } else
  1447.             con = this.driver.globalConnection;

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

  1451.         try {
  1452.             this.driver.logDebug("CRUDServizioApplicativo type = 1");
  1453.             // creo soggetto
  1454.             DriverConfigurazioneDB_serviziApplicativiLIB.CRUDServizioApplicativo(1, aSA, con, this.driver.getDriverWrapBYOK());

  1456.         } catch (Exception qe) {
  1457.             error = true;
  1458.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createServizioApplicativo] Errore durante la creazione del servizioApplicativo : " + qe.getMessage(),qe);
  1459.         } finally {

  1461.             this.driver.closeConnection(error,con);
  1462.         }
  1463.     }

  1465.     /**
  1466.      * 
  1467.      * @param aSA
  1468.      * @throws DriverConfigurazioneException
  1469.      */
  1470.     protected void updateServizioApplicativo(ServizioApplicativo aSA) throws DriverConfigurazioneException {
  1471.         if (aSA == null)
  1472.             throw new DriverConfigurazioneException("Servizio Applicativo non valida");
  1473.         if (aSA.getNome() == null || aSA.getNome().equals(""))
  1474.             throw new DriverConfigurazioneException("Nome Servizio Applicativo non valido");
  1475.         if (aSA.getNomeSoggettoProprietario() == null || aSA.getNomeSoggettoProprietario().equals(""))
  1476.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Servizio Applicativo non valido");
  1477.         if (aSA.getTipoSoggettoProprietario() == null || aSA.getTipoSoggettoProprietario().equals(""))
  1478.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Servizio Applicativo non valido");

  1480.         Connection con = null;
  1481.         boolean error = false;

  1483.         if (this.driver.atomica) {
  1484.             try {
  1485.                 con = this.driver.getConnectionFromDatasource("updateServizioApplicativo");
  1486.                 con.setAutoCommit(false);
  1487.             } catch (Exception e) {
  1488.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateServizioApplicativo] Exception accedendo al datasource :" + e.getMessage(),e);

  1490.             }

  1492.         } else
  1493.             con = this.driver.globalConnection;

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

  1497.         try {
  1498.             this.driver.logDebug("CRUDServizioApplicativo type = 2");
  1499.             // creo soggetto
  1500.             DriverConfigurazioneDB_serviziApplicativiLIB.CRUDServizioApplicativo(2, aSA, con, this.driver.getDriverWrapBYOK());

  1502.         } catch (Exception qe) {
  1503.             error = true;
  1504.             throw new DriverConfigurazioneException("Errore durante l'aggiornamento del servizioApplicativo : " + qe.getMessage(), qe);
  1505.         } finally {

  1507.             this.driver.closeConnection(error,con);
  1508.         }
  1509.     }

  1511.     protected void deleteServizioApplicativo(ServizioApplicativo aSA) throws DriverConfigurazioneException {
  1512.         if (aSA == null)
  1513.             throw new DriverConfigurazioneException("Servizio Applicativo non valida");
  1514.         if (aSA.getNome() == null || aSA.getNome().equals(""))
  1515.             throw new DriverConfigurazioneException("Nome Servizio Applicativo non valido");
  1516.         if (aSA.getNomeSoggettoProprietario() == null || aSA.getNomeSoggettoProprietario().equals(""))
  1517.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Servizio Applicativo non valido");
  1518.         if (aSA.getTipoSoggettoProprietario() == null || aSA.getTipoSoggettoProprietario().equals(""))
  1519.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Servizio Applicativo non valido");

  1521.         Connection con = null;
  1522.         boolean error = false;

  1524.         if (this.driver.atomica) {
  1525.             try {
  1526.                 con = this.driver.getConnectionFromDatasource("deleteServizioApplicativo");
  1527.                 con.setAutoCommit(false);
  1528.             } catch (Exception e) {
  1529.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteServizioApplicativo] Exception accedendo al datasource :" + e.getMessage(),e);

  1531.             }

  1533.         } else
  1534.             con = this.driver.globalConnection;

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

  1538.         try {
  1539.             this.driver.logDebug("CRUDServizioApplicativo type = 3");
  1540.             // creo soggetto
  1541.             DriverConfigurazioneDB_serviziApplicativiLIB.CRUDServizioApplicativo(3, aSA, con, this.driver.getDriverWrapBYOK());

  1543.         } catch (Exception qe) {
  1544.             error = true;
  1545.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteServizioApplicativo] Errore durante la delete del servizioApplicativo : " + qe.getMessage(),qe);
  1546.         } finally {

  1548.             this.driver.closeConnection(error,con);
  1549.         }
  1550.     }
  1551.     
  1552.     

  1554.     

  1556.     protected List<ServizioApplicativo> servizioApplicativoWithCredenzialiBasicList(String utente, String password, boolean checkPassword) throws DriverConfigurazioneException {
  1557.         String nomeMetodo = "servizioApplicativoWithCredenzialiBasicList";
  1558.         String queryString;

  1560.         Connection con = null;
  1561.         PreparedStatement stmt=null;
  1562.         ResultSet risultato=null;
  1563.         ArrayList<ServizioApplicativo> lista = new ArrayList<>();

  1565.         if (this.driver.atomica) {
  1566.             try {
  1567.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1568.             } catch (Exception e) {
  1569.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1571.             }

  1573.         } else
  1574.             con = this.driver.globalConnection;

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

  1578.         try {

  1580.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1581.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1582.             sqlQueryObject.addSelectField("id");
  1583.             sqlQueryObject.addSelectField("nome");
  1584.             sqlQueryObject.addSelectField("id_soggetto");
  1585.             sqlQueryObject.addWhereCondition("tipoauth = ?");
  1586.             sqlQueryObject.addWhereCondition("utente = ?");
  1587.             if(checkPassword) {
  1588.                 sqlQueryObject.addWhereCondition("password = ?");
  1589.             }
  1590.             sqlQueryObject.setANDLogicOperator(true);
  1591.             queryString = sqlQueryObject.createSQLQuery();
  1592.             stmt = con.prepareStatement(queryString);
  1593.             int index = 1;
  1594.             stmt.setString(index++, CredenzialeTipo.BASIC.getValue());
  1595.             stmt.setString(index++, utente);
  1596.             if(checkPassword) {
  1597.                 stmt.setString(index++, password);
  1598.             }
  1599.             risultato = stmt.executeQuery();

  1601.             ServizioApplicativo sa;
  1602.             while (risultato.next()) {

  1604.                 sa=this.getServizioApplicativo(risultato.getLong("id"));

  1606.                 lista.add(sa);

  1608.             }

  1610.             return lista;

  1612.         } catch (Exception qe) {
  1613.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1614.         } finally {

  1616.             //Chiudo statement and resultset
  1617.             JDBCUtilities.closeResources(risultato, stmt);

  1619.             this.driver.closeConnection(con);
  1620.         }
  1621.     }
  1622.     
  1623.     protected List<ServizioApplicativo> servizioApplicativoWithCredenzialiApiKeyList(String utente, boolean appId) throws DriverConfigurazioneException {
  1624.         String nomeMetodo = "servizioApplicativoWithCredenzialiApiKeyList";
  1625.         String queryString;

  1627.         Connection con = null;
  1628.         PreparedStatement stmt=null;
  1629.         ResultSet risultato=null;
  1630.         ArrayList<ServizioApplicativo> lista = new ArrayList<>();

  1632.         if (this.driver.atomica) {
  1633.             try {
  1634.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1635.             } catch (Exception e) {
  1636.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1638.             }

  1640.         } else
  1641.             con = this.driver.globalConnection;

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

  1645.         try {

  1647.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1648.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1649.             sqlQueryObject.addSelectField("id");
  1650.             sqlQueryObject.addSelectField("nome");
  1651.             sqlQueryObject.addSelectField("id_soggetto");
  1652.             sqlQueryObject.addWhereCondition("tipoauth = ?");
  1653.             sqlQueryObject.addWhereCondition("utente = ?");
  1654.             sqlQueryObject.addWhereCondition("issuer = ?");
  1655.             sqlQueryObject.setANDLogicOperator(true);
  1656.             queryString = sqlQueryObject.createSQLQuery();
  1657.             stmt = con.prepareStatement(queryString);
  1658.             int index = 1;
  1659.             stmt.setString(index++, CredenzialeTipo.APIKEY.getValue());
  1660.             stmt.setString(index++, utente);
  1661.             stmt.setString(index++, CostantiDB.getIssuerApiKey(appId));
  1662.             risultato = stmt.executeQuery();

  1664.             ServizioApplicativo sa;
  1665.             while (risultato.next()) {

  1667.                 sa=this.getServizioApplicativo(risultato.getLong("id"));

  1669.                 lista.add(sa);

  1671.             }

  1673.             return lista;

  1675.         } catch (Exception qe) {
  1676.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1677.         } finally {

  1679.             //Chiudo statement and resultset
  1680.             JDBCUtilities.closeResources(risultato, stmt);

  1682.             this.driver.closeConnection(con);
  1683.         }
  1684.     }

  1686.     protected List<ServizioApplicativo> servizioApplicativoWithCredenzialiSslList(String subject, String issuer,
  1687.             List<String> tipiSoggetto,
  1688.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws DriverConfigurazioneException {
  1689.         String nomeMetodo = "servizioApplicativoWithCredenzialiSslList";
  1690.         String queryString;

  1692.         Connection con = null;
  1693.         PreparedStatement stmt=null;
  1694.         ResultSet risultato=null;
  1695.         ArrayList<ServizioApplicativo> lista = new ArrayList<>();

  1697.         if (this.driver.atomica) {
  1698.             try {
  1699.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1700.             } catch (Exception e) {
  1701.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1703.             }

  1705.         } else
  1706.             con = this.driver.globalConnection;

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

  1710.         try {

  1712.             for (int i = 0; i < 2; i++) {
  1713.                             
  1714.                 String tabella = null;
  1715.                 if(i==0) {
  1716.                     tabella = CostantiDB.SERVIZI_APPLICATIVI;
  1717.                 }
  1718.                 else {
  1719.                     tabella = CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI;
  1720.                 }
  1721.                 
  1722.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1723.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1724.                 if(tipiSoggetto!=null) {
  1725.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1726.                 }
  1727.                 if(i>0) {
  1728.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  1729.                 }
  1730.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "saIdentificativo");
  1731.                 /**sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "nome", "saNome");
  1732.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id_soggetto", "saIdentificativoSoggetto");*/
  1733.                 sqlQueryObject.addSelectAliasField(tabella, "subject", "saSubject");
  1734.                 sqlQueryObject.addSelectAliasField(tabella, "issuer", "saIssuer");
  1735.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "tipoauth", "saTipoAuth");
  1736.                 
  1737.                 if(tipiSoggetto!=null) {
  1738.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  1739.                     if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  1740.                         ISQLQueryObject object =  buildFiltroApplicativiTls(sqlQueryObject, tipiSoggetto,
  1741.                                 includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  1742.                         sqlQueryObject.addWhereCondition(object.createSQLConditions());
  1743.                     } else {
  1744.                         sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  1745.                     }
  1746.                 }
  1747.                 if(i>0) {
  1748.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".id_servizio_applicativo="+CostantiDB.SERVIZI_APPLICATIVI+".id");
  1749.                 }
  1750.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?");
  1751.                 // I certificati caricati con una token policy potrebbero non dover essere considerati per l'autenticazione https
  1752.                 // in futuro se serve gestire il boolean tokenWithHttpsEnabled anche per l'autenticazione https
  1753.                 boolean tokenWithHttpsEnabled = false;
  1754.                 if(!tokenWithHttpsEnabled){
  1755.                     sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy");
  1756.                 }
  1757.                 
  1758.                 Map<String, List<String>> hashSubject = CertificateUtils.getPrincipalIntoMap(subject, PrincipalType.SUBJECT);
  1759.                 Map<String, List<String>> hashIssuer = null;
  1760.                 if(StringUtils.isNotEmpty(issuer)) {
  1761.                     hashIssuer = CertificateUtils.getPrincipalIntoMap(issuer, PrincipalType.ISSUER);
  1762.                 }
  1763.                 
  1764.                 for (String key : hashSubject.keySet()) {                   
  1765.                     List<String> listValues = hashSubject.get(key);
  1766.                     for (String value : listValues) {
  1767.                         sqlQueryObject.addWhereLikeCondition(tabella+".subject", "/"+CertificateUtils.formatKeyPrincipal(key)+"="+CertificateUtils.formatValuePrincipal(value)+"/", true, true, false);
  1768.                     }
  1769.                     
  1770.                 }
  1771.                 
  1772.                 if(hashIssuer!=null) {
  1773.                     for (String key : hashIssuer.keySet()) {
  1774.                         List<String> listValues = hashIssuer.get(key);
  1775.                         for (String value : listValues) {
  1776.                             sqlQueryObject.addWhereLikeCondition(tabella+".issuer", "/"+CertificateUtils.formatKeyPrincipal(key)+"="+CertificateUtils.formatValuePrincipal(value)+"/", true, true, false);
  1777.                         }
  1778.                     }
  1779.                     
  1780.                 }
  1781.                 else {
  1782.                     sqlQueryObject.addWhereIsNullCondition(tabella+".issuer");
  1783.                 }
  1784.                 
  1785.                 sqlQueryObject.setANDLogicOperator(true);
  1786.                 queryString = sqlQueryObject.createSQLQuery();
  1787.                 stmt = con.prepareStatement(queryString);
  1788.                 stmt.setString(1, CredenzialeTipo.SSL.getValue());
  1789.                 
  1790.                 risultato = stmt.executeQuery();
  1791.     
  1792.                 ServizioApplicativo sa;
  1793.                 while (risultato.next()) {
  1794.     
  1795.                     // Possono esistere piu' sil che hanno una porzione di subject uguale, devo quindi verificare che sia proprio quello che cerco
  1796.                     
  1797.                     String subjectPotenziale =  risultato.getString("saSubject");
  1798.                     boolean subjectValid = CertificateUtils.sslVerify(subjectPotenziale, subject, PrincipalType.SUBJECT, this.driver.log);
  1799.                     
  1800.                     boolean issuerValid = true;
  1801.                     if(hashIssuer!=null) {
  1802.                         String issuerPotenziale =  risultato.getString("saIssuer");
  1803.                         if(StringUtils.isNotEmpty(issuerPotenziale)) {
  1804.                             issuerValid = CertificateUtils.sslVerify(issuerPotenziale, issuer, PrincipalType.ISSUER, this.driver.log);
  1805.                         }
  1806.                         else {
  1807.                             issuerValid = false;
  1808.                         }
  1809.                     }
  1810.                     
  1811.                     if( !subjectValid || !issuerValid ) {
  1812.                         continue;
  1813.                     }
  1814.                     
  1815.                     sa=this.getServizioApplicativo(risultato.getLong("saIdentificativo"));
  1816.                     lista.add(sa);
  1817.                 }
  1818.                 risultato.close(); risultato = null;
  1819.                 stmt.close(); stmt = null;
  1820.                 
  1821.             }
  1822.             
  1823.             return lista;

  1825.         } catch (Exception qe) {
  1826.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1827.         } finally {

  1829.             //Chiudo statement and resultset
  1830.             JDBCUtilities.closeResources(risultato, stmt);

  1832.             this.driver.closeConnection(con);
  1833.         }
  1834.     }
  1835.     
  1836.     protected List<ServizioApplicativo> servizioApplicativoWithCredenzialiSslList(CertificateInfo certificate, boolean strictVerifier,
  1837.             List<String> tipiSoggetto,
  1838.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws DriverConfigurazioneException {
  1839.         String nomeMetodo = "servizioApplicativoWithCredenzialiSslList";
  1840.         String queryString;

  1842.         Connection con = null;
  1843.         PreparedStatement stmt=null;
  1844.         ResultSet risultato=null;
  1845.         ArrayList<ServizioApplicativo> lista = new ArrayList<>();

  1847.         if (this.driver.atomica) {
  1848.             try {
  1849.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1850.             } catch (Exception e) {
  1851.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1853.             }

  1855.         } else
  1856.             con = this.driver.globalConnection;

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

  1860.         try {
  1861.             
  1862.             
  1863.             for (int i = 0; i < 2; i++) {
  1864.                 
  1865.                 String tabella = null;
  1866.                 if(i==0) {
  1867.                     tabella = CostantiDB.SERVIZI_APPLICATIVI;
  1868.                 }
  1869.                 else {
  1870.                     tabella = CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI;
  1871.                 }

  1873.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1874.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1875.                 if(tipiSoggetto!=null) {
  1876.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1877.                 }
  1878.                 if(i>0) {
  1879.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI);
  1880.                 }
  1881.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "saIdentificativo");
  1882.                 /**sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "nome", "saNome");
  1883.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id_soggetto", "saIdentificativoSoggetto");*/
  1884.                 sqlQueryObject.addSelectAliasField(tabella, "cn_subject", "saCNSubject");
  1885.                 sqlQueryObject.addSelectAliasField(tabella, "cn_issuer", "saCNIssuer");
  1886.                 sqlQueryObject.addSelectAliasField(tabella, "cert_strict_verification", "saCertStrictVerificationr");
  1887.                 sqlQueryObject.addSelectAliasField(tabella, "certificate", "saCertificate");
  1888.                 
  1889.                 if(tipiSoggetto!=null) {
  1890.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  1891.                     if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  1892.                         ISQLQueryObject object =  buildFiltroApplicativiTls(sqlQueryObject, tipiSoggetto,
  1893.                                 includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  1894.                         sqlQueryObject.addWhereCondition(object.createSQLConditions());
  1895.                     } else {
  1896.                         sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiSoggetto.toArray(new String[1]));
  1897.                     }
  1898.                 }
  1899.                 if(i>0) {
  1900.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_CREDENZIALI+".id_servizio_applicativo="+CostantiDB.SERVIZI_APPLICATIVI+".id");
  1901.                 }
  1902.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?");
  1903.                 // I certificati caricati con una token policy potrebbero non dover essere considerati per l'autenticazione https
  1904.                 // in futuro se serve gestire il boolean tokenWithHttpsEnabled anche per l'autenticazione https
  1905.                 boolean tokenWithHttpsEnabled = false;
  1906.                 if(!tokenWithHttpsEnabled){
  1907.                     sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy");
  1908.                 }
  1909.                 sqlQueryObject.addWhereCondition(tabella+".cn_subject = ?");
  1910.                 sqlQueryObject.addWhereCondition(tabella+".cn_issuer = ?");
  1911.                 /**sqlQueryObject.addWhereCondition(tabella+".cert_strict_verification = ?");*/
  1912.                 
  1913.                 sqlQueryObject.setANDLogicOperator(true);
  1914.                 queryString = sqlQueryObject.createSQLQuery();
  1915.                 String cnSubject = certificate.getSubject().getCN();
  1916.                 String cnIssuer = certificate.getIssuer().getCN();
  1917.                 stmt = con.prepareStatement(queryString);
  1918.                 int indexStmt = 1;
  1919.                 stmt.setString(indexStmt++, CredenzialeTipo.SSL.getValue());
  1920.                 stmt.setString(indexStmt++, cnSubject);
  1921.                 stmt.setString(indexStmt++, cnIssuer);
  1922.                 // Il controllo serve ad evitare di caricare piu' applicativi con stesso certificato medesimo (indipendentemente dallo strict)
  1923.                 // Se quindi sto creando un entita con strict abilitato, verifichero sotto tra i vari certificati la corrispondenza esatta, altrimenti una corrispondenza non esatta
  1924.                 /**if(strictVerifier) {
  1925.                     stmt.setInt(indexStmt++, CostantiDB.TRUE);
  1926.                 }
  1927.                 else {
  1928.                     stmt.setInt(indexStmt++, CostantiDB.FALSE);
  1929.                 }*/
  1930.                 risultato = stmt.executeQuery();
  1931.     
  1932.                 ServizioApplicativo sa;
  1933.                 IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  1934.                 while (risultato.next()) {
  1935.     
  1936.                     // Possono esistere piu' servizi applicativi che hanno un CN con subject e issuer diverso.
  1937.                     
  1938.                     byte[] certificatoBytes = jdbcAdapter.getBinaryData(risultato, "saCertificate");
  1939.                     Certificate certificato = ArchiveLoader.load(ArchiveType.CER, certificatoBytes, 0, null);
  1940.                     /**int tmpStrict = rs.getInt("cert_strict_verification");
  1941.                     boolean strict = tmpStrict == CostantiDB.TRUE;*/
  1942.                     
  1943.                     if(!certificate.equals(certificato.getCertificate(),strictVerifier)) {
  1944.                         continue;
  1945.                     }
  1946.                     
  1947.                     sa=this.getServizioApplicativo(risultato.getLong("saIdentificativo"));
  1948.                     lista.add(sa);
  1949.                 }
  1950.                 risultato.close(); risultato=null;
  1951.                 stmt.close(); stmt=null;
  1952.             }

  1954.             return lista;

  1956.         } catch (Exception qe) {
  1957.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1958.         } finally {

  1960.             //Chiudo statement and resultset
  1961.             JDBCUtilities.closeResources(risultato, stmt);

  1963.             this.driver.closeConnection(con);
  1964.         }
  1965.     }
  1966.     
  1967.     protected List<ServizioApplicativo> servizioApplicativoWithCredenzialiPrincipalList(String principal) throws DriverConfigurazioneException {
  1968.         String nomeMetodo = "servizioApplicativoWithCredenzialiPrincipalList";
  1969.         String queryString;

  1971.         Connection con = null;
  1972.         PreparedStatement stmt=null;
  1973.         ResultSet risultato=null;
  1974.         ArrayList<ServizioApplicativo> lista = new ArrayList<>();

  1976.         if (this.driver.atomica) {
  1977.             try {
  1978.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1979.             } catch (Exception e) {
  1980.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1982.             }

  1984.         } else
  1985.             con = this.driver.globalConnection;

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

  1989.         try {

  1991.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1992.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1993.             sqlQueryObject.addSelectField("id");
  1994.             sqlQueryObject.addSelectField("nome");
  1995.             sqlQueryObject.addSelectField("id_soggetto");
  1996.             sqlQueryObject.addWhereCondition("tipoauth = ?");
  1997.             sqlQueryObject.addWhereCondition("utente = ?");
  1998.             sqlQueryObject.setANDLogicOperator(true);
  1999.             queryString = sqlQueryObject.createSQLQuery();
  2000.             stmt = con.prepareStatement(queryString);
  2001.             stmt.setString(1, CredenzialeTipo.PRINCIPAL.getValue());
  2002.             stmt.setString(2, principal);       
  2003.             risultato = stmt.executeQuery();

  2005.             ServizioApplicativo sa;
  2006.             while (risultato.next()) {

  2008.                 sa=this.getServizioApplicativo(risultato.getLong("id"));

  2010.                 lista.add(sa);

  2012.             }

  2014.             return lista;

  2016.         } catch (Exception qe) {
  2017.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2018.         } finally {

  2020.             //Chiudo statement and resultset
  2021.             JDBCUtilities.closeResources(risultato, stmt);

  2023.             this.driver.closeConnection(con);
  2024.         }
  2025.     }
  2026.     
  2027.     protected List<ServizioApplicativo> servizioApplicativoWithCredenzialiTokenList(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled) throws DriverConfigurazioneException {
  2028.         String nomeMetodo = "servizioApplicativoWithCredenzialiTokenList";
  2029.         String queryString;

  2031.         Connection con = null;
  2032.         PreparedStatement stmt=null;
  2033.         ResultSet risultato=null;
  2034.         ArrayList<ServizioApplicativo> lista = new ArrayList<>();

  2036.         if (this.driver.atomica) {
  2037.             try {
  2038.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2039.             } catch (Exception e) {
  2040.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2042.             }

  2044.         } else
  2045.             con = this.driver.globalConnection;

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

  2049.         try {

  2051.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2052.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2053.             sqlQueryObject.addSelectField("id");
  2054.             sqlQueryObject.addSelectField("nome");
  2055.             sqlQueryObject.addSelectField("id_soggetto");
  2056.             
  2057.             List<FiltroRicercaProtocolPropertyConfig> modiFilter = null; 
  2058.             if(tokenWithHttpsEnabled){
  2059.             
  2060.                 modiFilter = buildListModiTokenCredentials(tokenPolicy, tokenClientId);
  2061.                 
  2062.                 ISQLQueryObject sqlQueryObjectBuiltIn = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2063.                 sqlQueryObjectBuiltIn.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2064.                 sqlQueryObjectBuiltIn.addWhereCondition(false, "tipoauth = ?", "tipoauth = ?");
  2065.                 sqlQueryObjectBuiltIn.addWhereCondition("token_policy = ?");
  2066.                 sqlQueryObjectBuiltIn.addWhereCondition("utente = ?");
  2067.                 sqlQueryObjectBuiltIn.setANDLogicOperator(true);
  2068.                 
  2069.                 ISQLQueryObject sqlQueryObjectModi = buildSQLQueryObjectModiTokenCredentials(modiFilter);
  2070.                 
  2071.                 sqlQueryObject.addWhereCondition(sqlQueryObjectBuiltIn.createSQLConditions());
  2072.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectModi);
  2073.                 sqlQueryObject.setANDLogicOperator(false);
  2074.             }
  2075.             else {
  2076.                 sqlQueryObject.addWhereCondition("tipoauth = ?");
  2077.                 sqlQueryObject.addWhereCondition("token_policy = ?");
  2078.                 sqlQueryObject.addWhereCondition("utente = ?");
  2079.                 sqlQueryObject.setANDLogicOperator(true);
  2080.             }
  2081.             
  2082.             queryString = sqlQueryObject.createSQLQuery();
  2083.             stmt = con.prepareStatement(queryString);
  2084.             
  2085.             int index = 1;
  2086.             if(tokenWithHttpsEnabled){
  2087.                 stmt.setString(index++, CostantiConfigurazione.CREDENZIALE_TOKEN.toString());
  2088.                 stmt.setString(index++, CostantiConfigurazione.CREDENZIALE_SSL.toString());
  2089.                 stmt.setString(index++, tokenPolicy);
  2090.                 stmt.setString(index++, tokenClientId);
  2091.                 setSQLQueryObjectModiTokenCredentials (stmt, index, modiFilter);
  2092.             }
  2093.             else {
  2094.                 stmt.setString(index++, CostantiConfigurazione.CREDENZIALE_TOKEN.toString());
  2095.                 stmt.setString(index++, tokenPolicy);
  2096.                 stmt.setString(index++, tokenClientId);
  2097.             }
  2098.             
  2099.             this.driver.logDebug("eseguo query (tokenPolicy:"+tokenPolicy+" tokenClientId:"+tokenClientId+"):" +queryString);
  2100.             
  2101.             risultato = stmt.executeQuery();

  2103.             ServizioApplicativo sa;
  2104.             while (risultato.next()) {

  2106.                 sa=this.getServizioApplicativo(risultato.getLong("id"));

  2108.                 lista.add(sa);

  2110.             }

  2112.             return lista;

  2114.         } catch (Exception qe) {
  2115.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2116.         } finally {

  2118.             //Chiudo statement and resultset
  2119.             JDBCUtilities.closeResources(risultato, stmt);

  2121.             this.driver.closeConnection(con);
  2122.         }
  2123.     }

  2125.     protected String[] soggettiServizioApplicativoList(long idSoggetto) throws DriverConfigurazioneException {
  2126.         String nomeMetodo = "soggettiServizioApplicativoList";
  2127.         Connection con = null;
  2128.         PreparedStatement stmt=null;
  2129.         ResultSet risultato=null;
  2130.         String[] silList = null;

  2132.         if (this.driver.atomica) {
  2133.             try {
  2134.                 con = this.driver.getConnectionFromDatasource("soggettiServizioApplicativoList");
  2135.             } catch (Exception e) {
  2136.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2138.             }

  2140.         } else
  2141.             con = this.driver.globalConnection;

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

  2145.         try {

  2147.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2148.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2149.             sqlQueryObject.addSelectCountField("*", "cont");
  2150.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  2151.             String queryString = sqlQueryObject.createSQLQuery();
  2152.             stmt = con.prepareStatement(queryString);
  2153.             stmt.setLong(1, idSoggetto);
  2154.             risultato = stmt.executeQuery();
  2155.             if (risultato.next()) {
  2156.                 silList = new String[risultato.getInt(1)];
  2157.             }
  2158.             risultato.close();
  2159.             stmt.close();

  2161.             if(silList!=null) {
  2162.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2163.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2164.                 sqlQueryObject.addSelectField("nome");
  2165.                 sqlQueryObject.addSelectField("id_soggetto");
  2166.                 sqlQueryObject.addWhereCondition("id_soggetto = ?");
  2167.                 sqlQueryObject.addOrderBy("nome");
  2168.                 sqlQueryObject.setSortType(true);
  2169.                 queryString = sqlQueryObject.createSQLQuery();
  2170.                 stmt = con.prepareStatement(queryString);
  2171.                 stmt.setLong(1, idSoggetto);
  2172.                 risultato = stmt.executeQuery();
  2173.     
  2174.                 int i = 0;
  2175.                 while (risultato.next()) {
  2176.                     silList[i] = risultato.getString("nome");
  2177.                     i++;
  2178.                 }
  2179.             }

  2181.             return silList;

  2183.         } catch (Exception qe) {
  2184.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2185.         } finally {

  2187.             //Chiudo statement and resultset
  2188.             JDBCUtilities.closeResources(risultato, stmt);

  2190.             this.driver.closeConnection(con);
  2191.         }
  2192.     }

  2194.     protected List<IDServizioApplicativoDB> soggettiServizioApplicativoList(IDSoggetto idSoggetto,String superuser,CredenzialeTipo credenziale, Boolean appId, String tipoSA, 
  2195.             boolean bothSslAndToken, String tokenPolicy) throws DriverConfigurazioneException {
  2196.         return soggettiServizioApplicativoList(idSoggetto,superuser,credenziale, appId, tipoSA, bothSslAndToken, tokenPolicy, false);
  2197.     }
  2198.     protected List<IDServizioApplicativoDB> soggettiServizioApplicativoList(IDSoggetto idSoggetto,String superuser,CredenzialeTipo credenziale, Boolean appId, String tipoSA, 
  2199.             boolean bothSslAndToken, String tokenPolicy, boolean tokenPolicyOR) throws DriverConfigurazioneException {
  2200.         String nomeMetodo = "soggettiServizioApplicativoList";
  2201.         Connection con = null;
  2202.         PreparedStatement stmt=null;
  2203.         ResultSet risultato=null;
  2204.         ArrayList<IDServizioApplicativoDB> silList = new ArrayList<>();

  2206.         if (this.driver.atomica) {
  2207.             try {
  2208.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2209.             } catch (Exception e) {
  2210.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2212.             }

  2214.         } else
  2215.             con = this.driver.globalConnection;

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

  2219.         try {

  2221.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2222.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2223.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  2224.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "idServAppl");
  2225.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "nome", "nomeServAppl");
  2226.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI, "tipo_soggetto");
  2227.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI, "nome_soggetto");
  2228.             sqlQueryObject.addSelectField("id_soggetto");
  2229.             sqlQueryObject.addWhereCondition("id_soggetto = "+CostantiDB.SOGGETTI+".id");
  2230.             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto = ?");
  2231.             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto = ?");
  2232.             if(this.driver.useSuperUser && superuser!=null && (!"".equals(superuser)))
  2233.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".superuser = ?");
  2234.             if(tipoSA!=null) {
  2235.                 if(CostantiConfigurazione.CLIENT.equals(tipoSA)) {
  2236.                     sqlQueryObject.addWhereCondition(false, CostantiDB.SERVIZI_APPLICATIVI+".tipo = ?", CostantiDB.SERVIZI_APPLICATIVI+".as_client = ?");
  2237.                 }
  2238.                 else {
  2239.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipo = ?");
  2240.                 }
  2241.             }
  2242.             if(credenziale!=null) {
  2243.                 if(tokenPolicyOR) {
  2244.                     ISQLQueryObject sqlQueryObjectTrasporto = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2245.                     sqlQueryObjectTrasporto.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2246.                     sqlQueryObjectTrasporto.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?");
  2247.                     if(CredenzialeTipo.APIKEY.equals(credenziale) && appId!=null) {
  2248.                         sqlQueryObjectTrasporto.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".issuer = ?");
  2249.                     }
  2250.                     sqlQueryObjectTrasporto.setANDLogicOperator(true);
  2251.                     String trasporto = sqlQueryObjectTrasporto.createSQLConditions();
  2252.                     
  2253.                     ISQLQueryObject sqlQueryObjectToken = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2254.                     sqlQueryObjectToken.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2255.                     sqlQueryObjectToken.addWhereCondition(false, 
  2256.                             CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?",
  2257.                             CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ? AND "+CostantiDB.SERVIZI_APPLICATIVI+".token_policy IS NOT NULL AND "+CostantiDB.SERVIZI_APPLICATIVI+".utente IS NOT NULL");
  2258.                     if(tokenPolicy!=null) {
  2259.                         sqlQueryObjectToken.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy = ?");
  2260.                     }
  2261.                     sqlQueryObjectToken.setANDLogicOperator(true);
  2262.                     String token = sqlQueryObjectToken.createSQLConditions();
  2263.                     
  2264.                     sqlQueryObject.addWhereCondition(false, trasporto, token);
  2265.                 }
  2266.                 else {
  2267.                     if(CredenzialeTipo.TOKEN.equals(credenziale)){
  2268.                         if(bothSslAndToken) {
  2269.                             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ? AND "+CostantiDB.SERVIZI_APPLICATIVI+".token_policy IS NOT NULL AND "+CostantiDB.SERVIZI_APPLICATIVI+".utente IS NOT NULL");
  2270.                         }
  2271.                         else {
  2272.                             sqlQueryObject.addWhereCondition(false, 
  2273.                                     CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?",
  2274.                                     CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ? AND "+CostantiDB.SERVIZI_APPLICATIVI+".token_policy IS NOT NULL AND "+CostantiDB.SERVIZI_APPLICATIVI+".utente IS NOT NULL");
  2275.                         }
  2276.                     }
  2277.                     else {
  2278.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = ?");
  2279.                         if(CredenzialeTipo.SSL.equals(credenziale)){
  2280.                             // I certificati caricati con una token policy potrebbero non dover essere considerati per l'autenticazione https
  2281.                             // in futuro se serve gestire il boolean tokenWithHttpsEnabled anche per l'autenticazione https
  2282.                             boolean tokenWithHttpsEnabled = false;
  2283.                             if(!tokenWithHttpsEnabled){
  2284.                                 sqlQueryObject.addWhereIsNullCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy");
  2285.                             }
  2286.                         }
  2287.                     }
  2288.                     if(CredenzialeTipo.APIKEY.equals(credenziale) && appId!=null) {
  2289.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".issuer = ?");
  2290.                     }
  2291.                     if(tokenPolicy!=null) {
  2292.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".token_policy = ?");
  2293.                     }
  2294.                 }
  2295.             }
  2296.             sqlQueryObject.setANDLogicOperator(true);
  2297.             sqlQueryObject.addOrderBy("nome");
  2298.             sqlQueryObject.setSortType(true);
  2299.             String queryString = sqlQueryObject.createSQLQuery();
  2300.             stmt = con.prepareStatement(queryString);
  2301.             int index = 1;
  2302.             stmt.setString(index++, idSoggetto.getTipo());
  2303.             stmt.setString(index++, idSoggetto.getNome());
  2304.             if(this.driver.useSuperUser && superuser!=null && (!"".equals(superuser)))
  2305.                 stmt.setString(index++, superuser);
  2306.             if(tipoSA!=null) {
  2307.                 stmt.setString(index++, tipoSA);
  2308.                 if(CostantiConfigurazione.CLIENT.equals(tipoSA)) {
  2309.                     stmt.setInt(index++, CostantiDB.TRUE);
  2310.                 }
  2311.             }
  2312.             if(credenziale!=null) {
  2313.                 if(tokenPolicyOR) {
  2314.                     // trasporto
  2315.                     stmt.setString(index++, credenziale.getValue());
  2316.                     if(CredenzialeTipo.APIKEY.equals(credenziale) && appId!=null) {
  2317.                         stmt.setString(index++, CostantiDB.getIssuerApiKey(appId));
  2318.                     }
  2319.                     
  2320.                     // token
  2321.                     stmt.setString(index++, CredenzialeTipo.TOKEN.getValue());
  2322.                     stmt.setString(index++, CredenzialeTipo.SSL.getValue());
  2323.                     if(tokenPolicy!=null) {
  2324.                         stmt.setString(index++, tokenPolicy);
  2325.                     }
  2326.                 }
  2327.                 else {
  2328.                     if(CredenzialeTipo.TOKEN.equals(credenziale)){
  2329.                         if(bothSslAndToken) {
  2330.                             stmt.setString(index++, CredenzialeTipo.SSL.getValue());
  2331.                         }
  2332.                         else {
  2333.                             stmt.setString(index++, credenziale.getValue());
  2334.                             stmt.setString(index++, CredenzialeTipo.SSL.getValue());
  2335.                         }
  2336.                     }
  2337.                     else {
  2338.                         stmt.setString(index++, credenziale.getValue());
  2339.                     }

  2341.                     if(CredenzialeTipo.APIKEY.equals(credenziale) && appId!=null) {
  2342.                         stmt.setString(index++, CostantiDB.getIssuerApiKey(appId));
  2343.                     }
  2344.                     if(tokenPolicy!=null) {
  2345.                         stmt.setString(index++, tokenPolicy);
  2346.                     }
  2347.                 }
  2348.             }
  2349.             risultato = stmt.executeQuery();

  2351.             while (risultato.next()) {
  2352.                 
  2353.                 IDServizioApplicativoDB idSA = new IDServizioApplicativoDB();
  2354.                 idSA.setIdSoggettoProprietario(new IDSoggetto(risultato.getString("tipo_soggetto"), risultato.getString("nome_soggetto")));
  2355.                 idSA.setNome(risultato.getString("nomeServAppl"));
  2356.                 idSA.setId(risultato.getLong("idServAppl"));
  2357.                 silList.add(idSA);
  2358.             }

  2360.             return silList;

  2362.         } catch (Exception qe) {
  2363.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2364.         } finally {

  2366.             //Chiudo statement and resultset
  2367.             JDBCUtilities.closeResources(risultato, stmt);

  2369.             this.driver.closeConnection(con);
  2370.         }
  2371.     }
  2372.     
  2373.     protected List<String> nomiProprietaSA(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoSoggettiProtocollo) throws DriverConfigurazioneException {
  2374.         String queryString;

  2376.         Connection con = null;
  2377.         PreparedStatement stmt=null;
  2378.         ResultSet risultato=null;
  2379.         ArrayList<String> lista = new ArrayList<>();

  2381.         if (this.driver.atomica) {
  2382.             try {
  2383.                 con = this.driver.getConnectionFromDatasource("nomiProprietaSA");
  2384.             } catch (Exception e) {
  2385.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::nomiProprietaSA] Exception accedendo al datasource :" + e.getMessage(),e);

  2387.             }

  2389.         } else
  2390.             con = this.driver.globalConnection;

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

  2394.         try {

  2396.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2397.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_PROPS);
  2398.             sqlQueryObject.setSelectDistinct(true);
  2399.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI_APPLICATIVI_PROPS + ".nome");
  2400.             
  2401.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome)) || (tipoSoggettiProtocollo != null && tipoSoggettiProtocollo.size() > 0)) {
  2402.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  2403.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2404.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI + ".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  2405.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_PROPS+".id_servizio_applicativo="+CostantiDB.SERVIZI_APPLICATIVI+".id");
  2406.             }
  2407.             
  2408.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome))) {
  2409.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto=?");
  2410.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto=?");
  2411.             }
  2412.             
  2413.             if((tipoSoggettiProtocollo != null && tipoSoggettiProtocollo.size() > 0)) {
  2414.                 String [] tipiServiziProtocolloS = tipoSoggettiProtocollo.toArray(new String[tipoSoggettiProtocollo.size()]); 
  2415.                 sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipiServiziProtocolloS);
  2416.             }
  2417.             
  2418.             sqlQueryObject.addOrderBy(CostantiDB.SERVIZI_APPLICATIVI_PROPS + ".nome"); 
  2419.             sqlQueryObject.setSortType(true);
  2420.             sqlQueryObject.setANDLogicOperator(true);
  2421.             
  2422.             queryString = sqlQueryObject.createSQLQuery();
  2423.             stmt = con.prepareStatement(queryString);
  2424.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome))) {
  2425.                 stmt.setString(1, filterSoggettoTipo);
  2426.                 stmt.setString(2, filterSoggettoNome);
  2427.             }
  2428.             risultato = stmt.executeQuery();
  2429.             while (risultato.next()) {
  2430.                 lista.add(risultato.getString("nome"));
  2431.             }
  2432.             return lista;
  2433.         } catch (Exception qe) {
  2434.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::nomiProprietaSA] Errore : " + qe.getMessage(),qe);
  2435.         } finally {
  2436.             //Chiudo statement and resultset
  2437.             JDBCUtilities.closeResources(risultato, stmt);
  2438.             this.driver.closeConnection(con);
  2439.         }
  2440.     }
  2441.     
  2442.     protected List<IDServizioApplicativoDB> getIdServiziApplicativiWithIdErogatore(Long idErogatore, String tipo, 
  2443.             boolean checkIM, boolean checkConnettoreAbilitato) throws DriverConfigurazioneException {

  2445.         Connection con = null;
  2446.         PreparedStatement stm = null;
  2447.         ResultSet rs = null;
  2448.         String sqlQuery = "";
  2449.         ArrayList<IDServizioApplicativoDB> lista = new ArrayList<IDServizioApplicativoDB>();

  2451.         try {
  2452.             
  2453.             if (this.driver.atomica) {
  2454.                 try {
  2455.                     con = this.driver.getConnectionFromDatasource("getServiziApplicativiWithIdErogatore");
  2456.                 } catch (Exception e) {
  2457.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServiziApplicativiWithIdErogatore] Exception accedendo al datasource :" + e.getMessage(),e);

  2459.                 }

  2461.             } else
  2462.                 con = this.driver.globalConnection;
  2463.             
  2464.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2465.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2466.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  2467.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "id", "idServAppl");
  2468.             sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_APPLICATIVI, "nome", "nomeServAppl");
  2469.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI, "tipo_soggetto");
  2470.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI, "nome_soggetto");
  2471.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  2472.             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".id="+CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto");
  2473.             sqlQueryObject.setANDLogicOperator(true);
  2474.             if(tipo != null) {
  2475.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipo = ?");
  2476.             }
  2477.             if(checkConnettoreAbilitato) {
  2478.                 sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  2479.                 sqlQueryObject.addWhereCondition(CostantiDB.CONNETTORI+".id="+CostantiDB.SERVIZI_APPLICATIVI+".id_connettore_inv");
  2480.                 if(checkIM) {
  2481.                     sqlQueryObject.addWhereCondition(false,
  2482.                             CostantiDB.SERVIZI_APPLICATIVI+".getmsginv = ? ",
  2483.                             CostantiDB.CONNETTORI+".endpointtype <> ? " );
  2484.                 }
  2485.                 else {
  2486.                     sqlQueryObject.addWhereCondition(CostantiDB.CONNETTORI+".endpointtype <> ? " );
  2487.                 }
  2488.             }
  2489.             else if(checkIM) {
  2490.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".getmsginv = ? ");
  2491.             }
  2492.             
  2493.             sqlQuery = sqlQueryObject.createSQLQuery();
  2494.             stm = con.prepareStatement(sqlQuery);

  2496.             int index = 1;
  2497.             stm.setLong(index++, idErogatore);
  2498.             if(tipo != null) {
  2499.                 stm.setString(index++, tipo);
  2500.             }
  2501.             if(checkConnettoreAbilitato) {
  2502.                 if(checkIM) {
  2503.                     stm.setString(index++, DriverConfigurazioneDBLib.getValue(StatoFunzionalita.ABILITATO));
  2504.                     stm.setString(index++, TipiConnettore.DISABILITATO.getNome());
  2505.                 }
  2506.                 else {
  2507.                     stm.setString(index++, TipiConnettore.DISABILITATO.getNome());
  2508.                 }
  2509.             }
  2510.             else if(checkIM) {
  2511.                 stm.setString(index++, DriverConfigurazioneDBLib.getValue(StatoFunzionalita.ABILITATO));
  2512.             }

  2514.             String debugQuery = DBUtils.formatSQLString(sqlQuery, idErogatore);
  2515.             if(tipo != null) {
  2516.                 debugQuery = DBUtils.formatSQLString(debugQuery, tipo);
  2517.             }
  2518.             if(checkConnettoreAbilitato) {
  2519.                 if(checkIM) {
  2520.                     debugQuery = DBUtils.formatSQLString(debugQuery,  DriverConfigurazioneDBLib.getValue(StatoFunzionalita.ABILITATO));
  2521.                     debugQuery = DBUtils.formatSQLString(debugQuery,  TipiConnettore.DISABILITATO.getNome());
  2522.                 }
  2523.                 else {
  2524.                     debugQuery = DBUtils.formatSQLString(debugQuery,  TipiConnettore.DISABILITATO.getNome());
  2525.                 }
  2526.             }
  2527.             else if(checkIM) {
  2528.                 debugQuery = DBUtils.formatSQLString(debugQuery, DriverConfigurazioneDBLib.getValue(StatoFunzionalita.ABILITATO));
  2529.             }
  2530.             this.driver.logDebug("eseguo query : " + debugQuery);
  2531.             
  2532.             rs = stm.executeQuery();

  2534.             while (rs.next()) {
  2535.                 
  2536.                 IDServizioApplicativoDB idSA = new IDServizioApplicativoDB();
  2537.                 idSA.setIdSoggettoProprietario(new IDSoggetto(rs.getString("tipo_soggetto"), rs.getString("nome_soggetto")));
  2538.                 idSA.setNome(rs.getString("nomeServAppl"));
  2539.                 idSA.setId(rs.getLong("idServAppl"));
  2540.                 lista.add(idSA);
  2541.             }

  2543.             return lista;
  2544.         } catch (Exception qe) {
  2545.             throw new DriverConfigurazioneException(qe);
  2546.         } finally {

  2548.             JDBCUtilities.closeResources(rs, stm);
  2549.             
  2550.             this.driver.closeConnection(con);

  2552.         }

  2554.     }
  2555.     
  2556.     protected boolean existsServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException{

  2558.         IDSoggetto idSoggetto = idServizioApplicativo.getIdSoggettoProprietario();
  2559.         if(idSoggetto==null)throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsServizioApplicativo] Soggetto Fruitore non Impostato.");
  2560.         if(idServizioApplicativo.getNome()==null || "".equals(idServizioApplicativo.getNome()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsServizioApplicativo] Nome Servizio Applicativo non Impostato.");
  2561.         if(idSoggetto.getNome()==null || "".equals(idSoggetto.getNome()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsServizioApplicativo] Nome Soggetto Fruitore non Impostato.");
  2562.         if(idSoggetto.getTipo()==null || "".equals(idSoggetto.getTipo()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsServizioApplicativo] Nome Soggetto Fruitore non Impostato.");

  2564.         Connection con = null;

  2566.         try {
  2567.             
  2568.             if (this.driver.atomica) {
  2569.                 try {
  2570.                     con = this.driver.getConnectionFromDatasource("existsServizioApplicativo");
  2571.                 } catch (Exception e) {
  2572.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createAccessoRegistro] Exception accedendo al datasource :" + e.getMessage(),e);

  2574.                 }

  2576.             } else
  2577.                 con = this.driver.globalConnection;
  2578.             
  2579.             return DriverConfigurazioneDB_serviziApplicativiLIB.getIdServizioApplicativo(idServizioApplicativo.getNome(), idSoggetto.getTipo(), idSoggetto.getNome(), con, this.driver.tipoDB,this.driver.tabellaSoggetti)>0;
  2580.         } catch (Exception qe) {
  2581.             throw new DriverConfigurazioneException(qe);
  2582.         } finally {

  2584.             this.driver.closeConnection(con);

  2586.         }

  2588.     }

  2590.     protected long getIdServizioApplicativo(IDSoggetto idSoggetto, String nomeServizioApplicativo) throws DriverConfigurazioneException {

  2592.         if(idSoggetto==null)throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Soggetto Fruitore non Impostato.");
  2593.         if(nomeServizioApplicativo==null || "".equals(nomeServizioApplicativo))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Nome Servizio Applicativo non Impostato.");
  2594.         if(idSoggetto.getNome()==null || "".equals(idSoggetto.getNome()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Nome Soggetto Fruitore non Impostato.");
  2595.         if(idSoggetto.getTipo()==null || "".equals(idSoggetto.getTipo()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Tipo Soggetto Fruitore non Impostato.");

  2597.         Connection con = null;

  2599.         try {
  2600.             
  2601.             if (this.driver.atomica) {
  2602.                 try {
  2603.                     con = this.driver.getConnectionFromDatasource("getIdServizioApplicativo");
  2604.                 } catch (Exception e) {
  2605.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getServizioApplicativo] Exception accedendo al datasource :" + e.getMessage(),e);

  2607.                 }

  2609.             } else
  2610.                 con = this.driver.globalConnection;
  2611.             
  2612.             return DriverConfigurazioneDB_serviziApplicativiLIB.getIdServizioApplicativo(nomeServizioApplicativo, idSoggetto.getTipo(), idSoggetto.getNome(), con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  2613.         } catch (Exception qe) {
  2614.             throw new DriverConfigurazioneException(qe);
  2615.         } finally {

  2617.             this.driver.closeConnection(con);

  2619.         }

  2621.     }

  2623.     protected boolean existsServizioApplicativoSoggetto(Long idSoggetto) throws DriverConfigurazioneException {

  2625.         Connection con = null;
  2626.         PreparedStatement stm = null;
  2627.         ResultSet rs = null;
  2628.         String sqlQuery = "";

  2630.         try {
  2631.             
  2632.             if (this.driver.atomica) {
  2633.                 try {
  2634.                     con = this.driver.getConnectionFromDatasource("existsServizioApplicativoSoggetto");
  2635.                 } catch (Exception e) {
  2636.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsServizioApplicativoSoggetto] Exception accedendo al datasource :" + e.getMessage(),e);

  2638.                 }

  2640.             } else
  2641.                 con = this.driver.globalConnection;
  2642.             
  2643.             boolean esiste = false;
  2644.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2645.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2646.             sqlQueryObject.addSelectField("*");
  2647.             sqlQueryObject.addWhereCondition("id_soggetto=?");
  2648.             sqlQuery = sqlQueryObject.createSQLQuery();
  2649.             stm = con.prepareStatement(sqlQuery);

  2651.             stm.setLong(1, idSoggetto);

  2653.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idSoggetto));
  2654.             rs = stm.executeQuery();

  2656.             if (rs.next())
  2657.                 esiste = true;

  2659.             return esiste;
  2660.         } catch (Exception qe) {
  2661.             throw new DriverConfigurazioneException(qe);
  2662.         } finally {

  2664.             JDBCUtilities.closeResources(rs, stm);
  2665.             
  2666.             this.driver.closeConnection(con);

  2668.         }

  2670.     }
  2671.     
  2672.     protected boolean isServizioApplicativoInUsoComeErogatore(ServizioApplicativo sa, Map<ErrorsHandlerCostant, String> whereIsInUso) throws DriverConfigurazioneException {

  2674.         Connection con = null;
  2675.         PreparedStatement stmt=null;
  2676.         ResultSet risultato=null;

  2678.         try {

  2680.             if (this.driver.atomica) {
  2681.                 try {
  2682.                     con = this.driver.getConnectionFromDatasource("isServizioApplicativoInUsoComeErogatore");
  2683.                 } catch (Exception e) {
  2684.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::isServizioApplicativoInUsoComeErogatore] Exception accedendo al datasource :" + e.getMessage(),e);

  2686.                 }

  2688.             } else
  2689.                 con = this.driver.globalConnection;
  2690.             
  2691.             ArrayList<String> nomiPorteApplicative = new ArrayList<>();
  2692.             boolean isInUso=false;
  2693.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2694.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  2695.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2696.             sqlQueryObject.addSelectField("*");
  2697.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".id_servizio_applicativo = ?");
  2698.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  2699.             sqlQueryObject.setANDLogicOperator(true);
  2700.             String queryString = sqlQueryObject.createSQLQuery();
  2701.             stmt = con.prepareStatement(queryString);
  2702.             stmt.setLong(1, sa.getId());
  2703.             risultato = stmt.executeQuery();
  2704.             while (risultato.next()) {
  2705.                 isInUso=true;
  2706.                 nomiPorteApplicative.add(risultato.getString("nome_porta"));
  2707.             }
  2708.             risultato.close();
  2709.             stmt.close();


  2712.             if(isInUso){
  2713.                 if(whereIsInUso==null) whereIsInUso=new HashMap<ErrorsHandlerCostant, String>();

  2715.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, nomiPorteApplicative.toString());
  2716.             }

  2718.             return isInUso;

  2720.         } catch (Exception qe) {
  2721.             throw new DriverConfigurazioneException(qe);
  2722.         } finally {

  2724.             JDBCUtilities.closeResources(risultato, stmt);

  2726.             this.driver.closeConnection(con);

  2728.         }

  2730.     }
  2731.     
  2732.     protected List<ServizioApplicativo> getServiziApplicativiBySoggetto(long idSoggetto) throws DriverConfigurazioneException {
  2733.         String nomeMetodo = "getPorteApplicativeBySoggetto";

  2735.         Connection con = null;
  2736.         PreparedStatement stmt=null;
  2737.         ResultSet risultato=null;
  2738.         ArrayList<ServizioApplicativo> lista = new ArrayList<>();

  2740.         if (this.driver.atomica) {
  2741.             try {
  2742.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2743.             } catch (Exception e) {
  2744.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2746.             }

  2748.         } else
  2749.             con = this.driver.globalConnection;

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

  2753.         try {

  2755.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2756.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2757.             sqlQueryObject.addSelectField("id");
  2758.             sqlQueryObject.addWhereCondition("id_soggetto=?");
  2759.             String queryString = sqlQueryObject.createSQLQuery();
  2760.             stmt = con.prepareStatement(queryString);
  2761.             stmt.setLong(1, idSoggetto);
  2762.             risultato = stmt.executeQuery();

  2764.             while (risultato.next()) {

  2766.                 Long id = risultato.getLong("id");

  2768.                 ServizioApplicativo sa = this.getServizioApplicativo(id);

  2770.                 // Check per validazioneSemantica

  2772.                 if(sa.getInvocazionePorta()!=null && sa.getInvocazionePorta().sizeCredenzialiList()==0){
  2773.                     // Una invocazione porta senza credenziali equivale a non avere i dati di invocazione porta per la PdD. 
  2774.                     // ma l'interfaccia permette di farlo poiche' la configurazione avviene per step.
  2775.                     sa.setInvocazionePorta(null);
  2776.                 }

  2778.                 if(sa.getInvocazioneServizio()!=null && 
  2779.                         (sa.getInvocazioneServizio().getConnettore()==null || CostantiConfigurazione.DISABILITATO.equals(sa.getInvocazioneServizio().getConnettore().getTipo())) &&
  2780.                         CostantiConfigurazione.DISABILITATO.equals(sa.getInvocazioneServizio().getGetMessage()) ){
  2781.                     // Un' invocazione servizio senza connettore e senza getMessage equivale a non averlo per la PdD.
  2782.                     // ma l'interfaccia permette di farlo poiche' la configurazione avviene per step.
  2783.                     sa.setInvocazioneServizio(null);
  2784.                 }

  2786.                 if(sa.getRispostaAsincrona()!=null && 
  2787.                         (sa.getRispostaAsincrona().getConnettore()==null || CostantiConfigurazione.DISABILITATO.equals(sa.getRispostaAsincrona().getConnettore().getTipo())) &&
  2788.                         CostantiConfigurazione.DISABILITATO.equals(sa.getRispostaAsincrona().getGetMessage()) ){
  2789.                     // Un' invocazione servizio senza connettore e senza getMessage equivale a non averlo per la PdD.
  2790.                     // ma l'interfaccia permette di farlo poiche' la configurazione avviene per step.
  2791.                     sa.setRispostaAsincrona(null);
  2792.                 }

  2794.                 lista.add(sa);

  2796.             }

  2798.             return lista;

  2800.         } catch (Exception qe) {
  2801.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2802.         } finally {
  2803.             //Chiudo statement and resultset
  2804.             JDBCUtilities.closeResources(risultato, stmt);
  2805.             this.driver.closeConnection(con);
  2806.         }
  2807.     }
  2808.     
  2809.     protected List<IDServizioApplicativo> getAllIdServiziApplicativi(
  2810.             FiltroRicercaServiziApplicativi filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  2812.         Connection con = null;
  2813.         PreparedStatement stm = null;
  2814.         ResultSet rs = null;

  2816.         this.driver.logDebug("getAllIdServiziApplicativi...");

  2818.         try {
  2819.             this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  2820.             // prendo la connessione dal pool
  2821.             if (this.driver.atomica)
  2822.                 con = this.driver.getConnectionFromDatasource("getAllIdServiziApplicativi");
  2823.             else
  2824.                 con = this.driver.globalConnection;

  2826.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2827.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2828.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  2829.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI_APPLICATIVI+".nome");
  2830.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".tipo_soggetto");
  2831.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".nome_soggetto");
  2832.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  2833.             if(filtroRicerca!=null){
  2834.                 if(filtroRicerca.getIdRuolo()!=null){
  2835.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  2836.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_RUOLI+".id_servizio_applicativo = "+CostantiDB.SERVIZI_APPLICATIVI+".id");
  2837.                 }
  2838.             }

  2840.             if(filtroRicerca!=null){
  2841.                 // Filtro By Data
  2842.                 if(filtroRicerca.getMinDate()!=null)
  2843.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".ora_registrazione > ?");
  2844.                 if(filtroRicerca.getMaxDate()!=null)
  2845.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".ora_registrazione < ?");
  2846.                 if(filtroRicerca.getTipoSoggetto()!=null)
  2847.                     sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto = ?");
  2848.                 if(filtroRicerca.getNomeSoggetto()!=null)
  2849.                     sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto = ?");
  2850.                 if(filtroRicerca.getNome()!=null)
  2851.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".nome = ?");
  2852.                 if(filtroRicerca.getIdRuolo()!=null)
  2853.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_RUOLI+".ruolo = ?");
  2854.                 if(filtroRicerca.getTipo()!=null)
  2855.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipo = ?");
  2856.                 DBUtils.setPropertiesForSearch(sqlQueryObject, filtroRicerca.getProprieta(), CostantiDB.SERVIZI_APPLICATIVI, CostantiDB.SERVIZI_APPLICATIVI_PROPS, "nome", "valore", "id_servizio_applicativo");
  2857.                 this.protocolPropertiesDriver.setProtocolPropertiesForSearch(sqlQueryObject, filtroRicerca, CostantiDB.SERVIZI_APPLICATIVI);
  2858.             }

  2860.             sqlQueryObject.setANDLogicOperator(true);
  2861.             String sqlQuery = sqlQueryObject.createSQLQuery();
  2862.             this.driver.logDebug("eseguo query : " + sqlQuery );
  2863.             stm = con.prepareStatement(sqlQuery);
  2864.             int indexStmt = 1;
  2865.             if(filtroRicerca!=null){
  2866.                 if(filtroRicerca.getMinDate()!=null){
  2867.                     this.driver.logDebug("minDate stmt.setTimestamp("+filtroRicerca.getMinDate()+")");
  2868.                     stm.setTimestamp(indexStmt, new Timestamp(filtroRicerca.getMinDate().getTime()));
  2869.                     indexStmt++;
  2870.                 }
  2871.                 if(filtroRicerca.getMaxDate()!=null){
  2872.                     this.driver.logDebug("maxDate stmt.setTimestamp("+filtroRicerca.getMaxDate()+")");
  2873.                     stm.setTimestamp(indexStmt, new Timestamp(filtroRicerca.getMaxDate().getTime()));
  2874.                     indexStmt++;
  2875.                 }   
  2876.                 if(filtroRicerca.getTipoSoggetto()!=null){
  2877.                     this.driver.logDebug("tipoSoggetto stmt.setString("+filtroRicerca.getTipoSoggetto()+")");
  2878.                     stm.setString(indexStmt, filtroRicerca.getTipoSoggetto());
  2879.                     indexStmt++;
  2880.                 }
  2881.                 if(filtroRicerca.getNomeSoggetto()!=null){
  2882.                     this.driver.logDebug("nomeSoggetto stmt.setString("+filtroRicerca.getNomeSoggetto()+")");
  2883.                     stm.setString(indexStmt, filtroRicerca.getNomeSoggetto());
  2884.                     indexStmt++;
  2885.                 }       
  2886.                 if(filtroRicerca.getNome()!=null){
  2887.                     this.driver.logDebug("nome stmt.setString("+filtroRicerca.getNome()+")");
  2888.                     stm.setString(indexStmt, filtroRicerca.getNome());
  2889.                     indexStmt++;
  2890.                 }   
  2891.                 if(filtroRicerca.getIdRuolo()!=null){
  2892.                     this.driver.logDebug("ruolo stmt.setString("+filtroRicerca.getIdRuolo().getNome()+")");
  2893.                     stm.setString(indexStmt, filtroRicerca.getIdRuolo().getNome());
  2894.                     indexStmt++;
  2895.                 }
  2896.                 if(filtroRicerca.getTipo()!=null){
  2897.                     this.driver.logDebug("tipo stmt.setString("+filtroRicerca.getTipo()+")");
  2898.                     stm.setString(indexStmt, filtroRicerca.getTipo());
  2899.                     indexStmt++;
  2900.                 }
  2901.                 DBUtils.setPropertiesForSearch(stm, indexStmt, filtroRicerca.getProprieta(), this.driver.tipoDB, this.driver.log);
  2902.                 this.protocolPropertiesDriver.setProtocolPropertiesForSearch(stm, indexStmt, filtroRicerca, ProprietariProtocolProperty.SERVIZIO_APPLICATIVO);
  2903.             }
  2904.             rs = stm.executeQuery();
  2905.             List<IDServizioApplicativo> idsSA = new ArrayList<IDServizioApplicativo>();
  2906.             while (rs.next()) {
  2907.                 IDSoggetto idS = new IDSoggetto(rs.getString("tipo_soggetto"),rs.getString("nome_soggetto"));
  2908.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  2909.                 idSA.setIdSoggettoProprietario(idS);
  2910.                 idSA.setNome(rs.getString("nome"));
  2911.                 idsSA.add(idSA);
  2912.             }
  2913.             if(idsSA.size()==0){
  2914.                 if(filtroRicerca!=null)
  2915.                     throw new DriverConfigurazioneNotFound("ServiziApplicativi non trovati che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  2916.                 else
  2917.                     throw new DriverConfigurazioneNotFound("ServiziApplicativi non trovati");
  2918.             }else{
  2919.                 return idsSA;
  2920.             }
  2921.         }catch(DriverConfigurazioneNotFound de){
  2922.             throw de;
  2923.         }
  2924.         catch(Exception e){
  2925.             throw new DriverConfigurazioneException("getAllIdServiziApplicativi error",e);
  2926.         } finally {

  2928.             //Chiudo statement and resultset
  2929.             JDBCUtilities.closeResources(rs, stm);

  2931.             this.driver.closeConnection(con);

  2933.         }

  2935.     }
  2936.     
  2937.     protected long getIdServizioApplicativoByConnettore(long idConnettore) throws DriverConfigurazioneException {
  2938.         String nomeMetodo = "getIdServizioApplicativoByConnettore";

  2940.         Connection con = null;

  2942.         if (this.driver.atomica) {
  2943.             try {
  2944.                 con = this.driver.getConnectionFromDatasource("getProtocolProperty");

  2946.             } catch (Exception e) {
  2947.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(), e);

  2949.             }

  2951.         } else {
  2952.             con = this.driver.globalConnection;
  2953.         }

  2955.         PreparedStatement stmt=null;
  2956.         ResultSet risultato=null;
  2957.         try {

  2959.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2960.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2961.             sqlQueryObject.addSelectField("id");
  2962.             sqlQueryObject.addWhereCondition("id_connettore_inv=?");
  2963.             sqlQueryObject.addWhereCondition("id_connettore_risp=?");
  2964.             sqlQueryObject.setANDLogicOperator(false);
  2965.             String queryString = sqlQueryObject.createSQLQuery();
  2966.             stmt = con.prepareStatement(queryString);
  2967.             stmt.setLong(1, idConnettore);
  2968.             stmt.setLong(2, idConnettore);
  2969.             risultato = stmt.executeQuery();
  2970.             long idSA = -1;
  2971.             if (risultato.next()) {
  2972.                 idSA = risultato.getLong("id");
  2973.             }           
  2974.             return idSA;

  2976.         } catch (Exception se) {
  2977.             throw new DriverConfigurazioneException("[DriverConfigurazioneException::" + nomeMetodo + "] Exception: " + se.getMessage());
  2978.         } finally {
  2979.             //Chiudo statement and resultset
  2980.             JDBCUtilities.closeResources(risultato, stmt);
  2981.             this.driver.closeConnection(con);
  2982.         }
  2983.     }
  2984.     
  2985.     protected IDServizio getLabelNomeServizioApplicativo(String nomeServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  2986.         
  2987.         // viene inserito come azione dell'IDServizio
  2988.         
  2989.         Connection con = null;
  2990.         ResultSet rs = null;
  2991.         PreparedStatement stm = null;
  2992.         
  2993.         if (this.driver.atomica) {
  2994.             try {
  2995.                 con = this.driver.getConnectionFromDatasource("findAllAllarmi");

  2997.             } catch (Exception e) {
  2998.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::findAllAllarmi] Exception accedendo al datasource :" + e.getMessage(),e);

  3000.             }

  3002.         } else
  3003.             con = this.driver.globalConnection;

  3005.         try {

  3007.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3008.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  3009.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI_APPLICATIVI + ".id");
  3010.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI_APPLICATIVI + ".tipo");
  3011.             sqlQueryObject.setANDLogicOperator(true);
  3012.             sqlQueryObject.addWhereCondition("nome=?");

  3014.             String sqlQuery = sqlQueryObject.createSQLQuery();

  3016.             stm = con.prepareStatement(sqlQuery);
  3017.             stm.setString(1, nomeServizioApplicativo);

  3019.             this.driver.logDebug("eseguo query: " + sqlQuery);
  3020.             
  3021.             long idSA = -1;
  3022.             String tipo = null;
  3023.             rs = stm.executeQuery();
  3024.             if(rs.next()) {
  3025.                 idSA = rs.getLong("id");
  3026.                 tipo = rs.getString("tipo");
  3027.             }
  3028.             rs.close(); rs=null;
  3029.             stm.close(); stm = null;

  3031.             if(idSA>0) {

  3033.                 if(CostantiConfigurazione.SERVER.equals(tipo)){
  3034.                     return null; // non serve normalizzazione, si puo' usare il nome stesso
  3035.                 }
  3036.                 
  3037.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3038.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  3039.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3040.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  3041.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE + ".behaviour");
  3042.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE_SA + ".connettore_nome");
  3043.                 sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".tipo_soggetto");
  3044.                 sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".nome_soggetto");
  3045.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE + ".tipo_servizio");
  3046.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE + ".servizio");
  3047.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE + ".versione_servizio");
  3048.                 sqlQueryObject.setANDLogicOperator(true);
  3049.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE + ".id="+CostantiDB.PORTE_APPLICATIVE_SA + ".id_porta");
  3050.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI + ".id="+CostantiDB.PORTE_APPLICATIVE + ".id_soggetto");
  3051.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA + ".id_servizio_applicativo=?");

  3053.                 sqlQuery = sqlQueryObject.createSQLQuery();
  3054.                 
  3055.                 stm = con.prepareStatement(sqlQuery);
  3056.                 stm.setLong(1, idSA);

  3058.                 this.driver.logDebug("eseguo query: " + sqlQuery);
  3059.                 
  3060.                 List<IDServizio> nomiConnettore = new ArrayList<IDServizio>();
  3061.                 rs = stm.executeQuery();
  3062.                 while(rs.next()) {
  3063.                     
  3064.                     String behaviour = rs.getString("behaviour");
  3065.                     String nomeConnettore = rs.getString("connettore_nome");
  3066.                     
  3067.                     String tipo_soggetto = rs.getString("tipo_soggetto");
  3068.                     String nome_soggetto = rs.getString("nome_soggetto");
  3069.                     String tipo_servizio = rs.getString("tipo_servizio");
  3070.                     String servizio = rs.getString("servizio");
  3071.                     int versione_servizio = rs.getInt("versione_servizio");
  3072.                     
  3073.                     IDServizio idServizio = IDServizioUtils.buildIDServizio(tipo_servizio, servizio,
  3074.                             new IDSoggetto(tipo_soggetto, nome_soggetto),
  3075.                             versione_servizio);
  3076.                     
  3077.                     if(nomeConnettore!=null && !"".equals(nomeConnettore)) {
  3078.                         idServizio.setAzione(nomeConnettore);
  3079.                     }
  3080.                     else {
  3081.                         if(behaviour!=null && !"".equals(behaviour)) {
  3082.                             idServizio.setAzione(CostantiConfigurazione.NOME_CONNETTORE_DEFAULT);
  3083.                         }
  3084.                     }

  3086.                     nomiConnettore.add(idServizio);
  3087.                 }
  3088.                 rs.close(); rs=null;
  3089.                 stm.close(); stm = null;
  3090.                 
  3091.                 if(!nomiConnettore.isEmpty() && nomiConnettore.size()==1) {
  3092.                     return nomiConnettore.get(0);
  3093.                 }
  3094.                 // else esistono più associazione e non e' di tipo server ???
  3095.             }
  3096.             
  3097.             return null; // normalizzazione non riuscita, si puo' usare il nome stesso
  3098.             
  3099.         } catch (Exception se) {
  3100.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::findAllAllarmi] Exception: " + se.getMessage(),se);
  3101.         } finally {
  3102.             //Chiudo statement and resultset
  3103.             JDBCUtilities.closeResources(rs, stm);
  3104.             this.driver.closeConnection(con);
  3105.         }
  3106.         
  3107.     }
  3108.     
  3109.     protected ProprietaOggetto getProprietaOggetto(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  3110.         
  3111.         String nomeMetodo = "getProprietaOggetto";
  3112.         
  3113.         IDSoggetto idSoggetto = idServizioApplicativo.getIdSoggettoProprietario();
  3114.         if(idSoggetto==null)throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Soggetto Fruitore non Impostato.");
  3115.         if(idServizioApplicativo.getNome()==null || "".equals(idServizioApplicativo.getNome()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Nome Servizio Applicativo non Impostato.");
  3116.         if(idSoggetto.getNome()==null || "".equals(idSoggetto.getNome()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Nome Soggetto Fruitore non Impostato.");
  3117.         if(idSoggetto.getTipo()==null || "".equals(idSoggetto.getTipo()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Tipo Soggetto Fruitore non Impostato.");

  3119.         
  3120.         Connection con = null;
  3121.         PreparedStatement stm = null;
  3122.         ResultSet rs = null;
  3123.         String sqlQuery = "";

  3125.         if (this.driver.atomica) {
  3126.             try {
  3127.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);

  3129.             } catch (Exception e) {
  3130.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Exception accedendo al datasource :" + e.getMessage(),e);

  3132.             }

  3134.         } else
  3135.             con = this.driver.globalConnection;

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

  3139.         try {
  3140.             long idSog=DBUtils.getIdSoggetto(idSoggetto.getNome(), idSoggetto.getTipo(), con, this.driver.tipoDB,this.driver.tabellaSoggetti);

  3142.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3143.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  3144.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE);
  3145.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE);
  3146.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA);
  3147.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA);
  3148.             sqlQueryObject.addWhereCondition("nome = ?");
  3149.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  3150.             sqlQueryObject.setANDLogicOperator(true);
  3151.             sqlQuery = sqlQueryObject.createSQLQuery();
  3152.             stm = con.prepareStatement(sqlQuery);
  3153.             stm.setString(1, idServizioApplicativo.getNome());
  3154.             stm.setLong(2, idSog);
  3155.             this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery, idServizioApplicativo.getNome(), idSog));
  3156.             
  3157.             rs = stm.executeQuery();

  3159.             ProprietaOggetto proprieta = null;
  3160.             if (rs.next()) {            
  3161.                 proprieta = this.utilsDriver.readProprietaOggetto(rs,false);
  3162.             }
  3163.             else{
  3164.                 throw new DriverConfigurazioneNotFound("ServizioApplicativo ["+idServizioApplicativo.getNome()+"] non esistente");
  3165.             }

  3167.             return proprieta;

  3169.         } catch (SQLException se) {

  3171.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] SqlException: " + se.getMessage(),se);
  3172.         } catch (Exception se) {

  3174.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Exception: " + se.getMessage(),se);
  3175.         }
  3176.         finally {

  3178.             //Chiudo statement and resultset
  3179.             JDBCUtilities.closeResources(rs, stm);
  3180.             this.driver.closeConnection(con);
  3181.         }
  3182.     }
  3183.     
  3184.     protected void updateProprietaOggetto(IDServizioApplicativo idServizioApplicativo, String user) throws DriverConfigurazioneException {
  3185.         
  3186.         String nomeMetodo = "updateProprietaOggettoServizioApplicativo";
  3187.         
  3188.         IDSoggetto idSoggetto = idServizioApplicativo.getIdSoggettoProprietario();
  3189.         if(idSoggetto==null)throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Soggetto Fruitore non Impostato.");
  3190.         if(idServizioApplicativo.getNome()==null || "".equals(idServizioApplicativo.getNome()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Nome Servizio Applicativo non Impostato.");
  3191.         if(idSoggetto.getNome()==null || "".equals(idSoggetto.getNome()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Nome Soggetto Fruitore non Impostato.");
  3192.         if(idSoggetto.getTipo()==null || "".equals(idSoggetto.getTipo()))throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Tipo Soggetto Fruitore non Impostato.");

  3194.         
  3195.         Connection con = null;
  3196.         if (this.driver.atomica) {
  3197.             try {
  3198.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  3199.             } catch (Exception e) {
  3200.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3202.             }

  3204.         } else
  3205.             con = this.driver.globalConnection;

  3207.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  3208.         
  3209.         PreparedStatement stm = null;
  3210.         try {
  3211.             long idSog=DBUtils.getIdSoggetto(idSoggetto.getNome(), idSoggetto.getTipo(), con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  3212.             
  3213.             ISQLQueryObject sqlQueryObjectUpdate = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3214.             sqlQueryObjectUpdate.addUpdateTable(CostantiDB.SERVIZI_APPLICATIVI);
  3215.             sqlQueryObjectUpdate.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA, "?");
  3216.             sqlQueryObjectUpdate.addUpdateField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA, "?");
  3217.             sqlQueryObjectUpdate.addWhereCondition("nome = ?");
  3218.             sqlQueryObjectUpdate.addWhereCondition("id_soggetto = ?");
  3219.             sqlQueryObjectUpdate.setANDLogicOperator(true);
  3220.             String updateString = sqlQueryObjectUpdate.createSQLUpdate();
  3221.             stm = con.prepareStatement(updateString);
  3222.             int index = 1;
  3223.             stm.setString(index++, user);
  3224.             stm.setTimestamp(index++, DateManager.getTimestamp());
  3225.             stm.setString(index++, idServizioApplicativo.getNome());
  3226.             stm.setLong(index++, idSog);
  3227.             int n=stm.executeUpdate();
  3228.             stm.close();
  3229.             this.driver.logDebug("Aggiornata "+n+" entry per l'operazione di ultima modifica della tabella '"+CostantiDB.SERVIZI_APPLICATIVI+"' con idSA: "+idServizioApplicativo);
  3230.         } catch (SQLException e) {
  3231.             this.driver.logError("Errore SQL", e);
  3232.             throw new DriverConfigurazioneException(e);
  3233.         }catch (Exception e) {
  3234.             this.driver.logError("Errore", e);
  3235.             throw new DriverConfigurazioneException(e);
  3236.         } finally {
  3237.             JDBCUtilities.closeResources(stm);

  3239.             this.driver.closeConnection(con);
  3240.         }
  3241.     }
  3242. }
Created with JaCoCo 0.8.8.202204050719