DriverConfigurazioneDB_porteDelegateDriver.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.List;

  30. import org.apache.commons.lang.StringUtils;
  31. import org.openspcoop2.core.byok.IDriverBYOK;
  32. import org.openspcoop2.core.commons.CoreException;
  33. import org.openspcoop2.core.commons.DBUtils;
  34. import org.openspcoop2.core.commons.IExtendedInfo;
  35. import org.openspcoop2.core.config.AttributeAuthority;
  36. import org.openspcoop2.core.config.AutorizzazioneRuoli;
  37. import org.openspcoop2.core.config.AutorizzazioneScope;
  38. import org.openspcoop2.core.config.ConfigurazioneMessageHandlers;
  39. import org.openspcoop2.core.config.ConfigurazionePortaHandler;
  40. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  41. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  42. import org.openspcoop2.core.config.CorrelazioneApplicativaRisposta;
  43. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  44. import org.openspcoop2.core.config.CorsConfigurazione;
  45. import org.openspcoop2.core.config.DumpConfigurazione;
  46. import org.openspcoop2.core.config.GestioneToken;
  47. import org.openspcoop2.core.config.GestioneTokenAutenticazione;
  48. import org.openspcoop2.core.config.MessageSecurity;
  49. import org.openspcoop2.core.config.MessageSecurityFlow;
  50. import org.openspcoop2.core.config.MessageSecurityFlowParameter;
  51. import org.openspcoop2.core.config.MtomProcessor;
  52. import org.openspcoop2.core.config.MtomProcessorFlow;
  53. import org.openspcoop2.core.config.MtomProcessorFlowParameter;
  54. import org.openspcoop2.core.config.PortaDelegata;
  55. import org.openspcoop2.core.config.PortaDelegataAutorizzazioneServiziApplicativi;
  56. import org.openspcoop2.core.config.PortaDelegataAutorizzazioneToken;
  57. import org.openspcoop2.core.config.PortaDelegataAzione;
  58. import org.openspcoop2.core.config.PortaDelegataLocalForward;
  59. import org.openspcoop2.core.config.PortaDelegataServizio;
  60. import org.openspcoop2.core.config.PortaDelegataServizioApplicativo;
  61. import org.openspcoop2.core.config.PortaDelegataSoggettoErogatore;
  62. import org.openspcoop2.core.config.PortaTracciamento;
  63. import org.openspcoop2.core.config.Proprieta;
  64. import org.openspcoop2.core.config.ProprietaOggetto;
  65. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  66. import org.openspcoop2.core.config.Ruolo;
  67. import org.openspcoop2.core.config.Scope;
  68. import org.openspcoop2.core.config.TracciamentoConfigurazione;
  69. import org.openspcoop2.core.config.TracciamentoConfigurazioneFiletrace;
  70. import org.openspcoop2.core.config.Transazioni;
  71. import org.openspcoop2.core.config.Trasformazioni;
  72. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  73. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  74. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  75. import org.openspcoop2.core.config.constants.RuoloTipoMatch;
  76. import org.openspcoop2.core.config.constants.RuoloTipologia;
  77. import org.openspcoop2.core.config.constants.ScopeTipoMatch;
  78. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  79. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  80. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  81. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  82. import org.openspcoop2.core.config.driver.IDServizioUtils;
  83. import org.openspcoop2.core.constants.CostantiDB;
  84. import org.openspcoop2.core.id.IDPortaDelegata;
  85. import org.openspcoop2.core.id.IDServizio;
  86. import org.openspcoop2.core.id.IDSoggetto;
  87. import org.openspcoop2.core.id.IdentificativiFruizione;
  88. import org.openspcoop2.core.mapping.DBMappingUtils;
  89. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  90. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  91. import org.openspcoop2.utils.sql.ISQLQueryObject;
  92. import org.openspcoop2.utils.sql.SQLObjectFactory;

  94. /**
  95.  * DriverConfigurazioneDB_porteDelegateDriver
  96.  * 
  97.  * 
  98.  * @author Sandra Giangrandi (sandra@link.it)
  99.  * @author Stefano Corallo (corallo@link.it)
  100.  * @author $Author$
  101.  * @version $Rev$, $Date$
  102.  */
  103. public class DriverConfigurazioneDB_porteDelegateDriver {

  105.     private DriverConfigurazioneDB driver = null;
  106.     private DriverConfigurazioneDB_porteDriver porteDriver = null;
  107.     private DriverConfigurazioneDBSoggetti soggettiDriver = null;
  108.     private DriverConfigurazioneDBUtils utilsDriver = null;
  109.     
  110.     protected DriverConfigurazioneDB_porteDelegateDriver(DriverConfigurazioneDB driver) {
  111.         this.driver = driver;
  112.         this.porteDriver = new DriverConfigurazioneDB_porteDriver(driver);
  113.         this.soggettiDriver = new DriverConfigurazioneDBSoggetti(driver);
  114.         this.utilsDriver = new DriverConfigurazioneDBUtils(driver);
  115.     }
  116.     
  117.     protected IDPortaDelegata getIDPortaDelegata(String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  118.         
  119.         String nomeMetodo = "getIDPortaDelegata";
  120.         
  121.         if (nome == null)
  122.             throw new DriverConfigurazioneException("["+nomeMetodo+"] Parametro Non Valido");

  124.         Connection con = null;
  125.         PreparedStatement stm = null;
  126.         ResultSet rs = null;
  127.         String sqlQuery = "";

  129.         if (this.driver.atomica) {
  130.             try {
  131.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);

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

  136.             }

  138.         } else
  139.             con = this.driver.globalConnection;

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

  143.         try {
  144.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  145.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  146.             sqlQueryObject.addSelectField("*");
  147.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  148.             sqlQuery = sqlQueryObject.createSQLQuery();
  149.             stm = con.prepareStatement(sqlQuery);

  151.             stm.setString(1, nome);

  153.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, nome));
  154.             rs = stm.executeQuery();

  156.             IDPortaDelegata idPD = null;
  157.             if (rs.next()) {
  158.                 
  159.                 idPD = new IDPortaDelegata();
  160.                 
  161.                 idPD.setNome(rs.getString("nome_porta"));
  162.                 
  163.                 IdentificativiFruizione idFruizione = new IdentificativiFruizione();
  164.                 
  165.                 try{
  166.                     long idSoggProprietario = rs.getLong("id_soggetto");
  167.                     IDSoggetto idSoggettoProprietario = this.soggettiDriver.getIdSoggetto(idSoggProprietario,con);
  168.                     idFruizione.setSoggettoFruitore(idSoggettoProprietario);
  169.                 } catch (Exception se) {
  170.                     throw new Exception(se.getMessage()); // mappo NotFound in una eccezione generica. Il Soggetto proprietario deve esistere
  171.                 }
  172.                 
  173.                 String nomeSoggettoErogatore = rs.getString("nome_soggetto_erogatore");
  174.                 String tipoSoggettoErogatore = rs.getString("tipo_soggetto_erogatore");
  175.                 long idSoggettoErogatoreDB = rs.getLong("id_soggetto_erogatore");
  176.                 long idSoggErogatore=-1;
  177.                 if( (idSoggettoErogatoreDB==-2) || (idSoggettoErogatoreDB>0) ){
  178.                     idSoggErogatore = idSoggettoErogatoreDB;
  179.                 }
  180.                 else{
  181.                     try {
  182.                         idSoggErogatore = DBUtils.getIdSoggetto(nomeSoggettoErogatore, tipoSoggettoErogatore, con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  183.                     } catch (CoreException e) {
  184.                         this.driver.logDebug(e.getMessage(),e);
  185.                     }
  186.                 }
  187.                 IDSoggetto idSoggettoErogatore = null;
  188.                 if(idSoggErogatore>0){
  189.                     idSoggettoErogatore = new IDSoggetto();
  190.                     idSoggettoErogatore.setTipo(tipoSoggettoErogatore);
  191.                     idSoggettoErogatore.setNome(nomeSoggettoErogatore);
  192.                 }else{
  193.                     throw new DriverConfigurazioneException("Soggetto Erogatore della Porta Delegata ["+nome+"] non presente.");
  194.                 }

  196.                 String tipoServizio = rs.getString("tipo_servizio");
  197.                 String nomeServizio = rs.getString("nome_servizio");
  198.                 Integer versioneServizio = rs.getInt("versione_servizio");
  199.                 long idServizioDB = rs.getLong("id_servizio");
  200.                 long idServizio=-1;
  201.                 if( (idServizioDB==-2) || (idServizioDB>0) ){
  202.                     idServizio = idServizioDB;
  203.                 }
  204.                 else{
  205.                     try {
  206.                         idServizio = DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeSoggettoErogatore, tipoSoggettoErogatore, con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  207.                     } catch (Exception e) {
  208.                         // NON Abilitare il log, poiche' la tabella servizi puo' non esistere per il driver di configurazione 
  209.                         // in un database che non ' quello della controlstation ma quello pdd.
  210.                         //this.driver.logDebug(e);
  211.                     }
  212.                 }
  213.                 IDServizio idServizioObject = null;
  214.                 if(idServizio>0){
  215.                     idServizioObject= IDServizioUtils.buildIDServizio(tipoServizio, nomeServizio, idSoggettoErogatore, versioneServizio);
  216.                 }

  218.                 String azione = rs.getString("nome_azione");
  219.                 if(azione!=null && (!"".equals(azione)) && idServizioObject!=null){
  220.                     idServizioObject.setAzione(azione);
  221.                 }
  222.                 idFruizione.setIdServizio(idServizioObject);

  224.                 
  225.                 idPD.setIdentificativiFruizione(idFruizione);   
  226.             }
  227.             else{
  228.                 throw new DriverConfigurazioneNotFound("PortaDelegata ["+nome+"] non esistente");
  229.             }

  231.             return idPD;

  233.         } catch (SQLException se) {

  235.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] SqlException: " + se.getMessage(),se);
  236.         } catch (DriverConfigurazioneException se) {
  237.             throw se;
  238.         } catch (DriverConfigurazioneNotFound se) {
  239.             throw se;
  240.         } catch (Exception se) {

  242.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Exception: " + se.getMessage(),se);
  243.         }
  244.         finally {

  246.             //Chiudo statement and resultset
  247.             JDBCUtilities.closeResources(rs, stm);
  248.             this.driver.closeConnection(con);
  249.         }
  250.     }
  251.     

  253.     protected PortaDelegata getPortaDelegata(IDPortaDelegata idPD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {

  255.         if (idPD == null)
  256.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] Parametro idPD Non Valido");

  258.         String nome = idPD.getNome();

  260.         if ((nome == null)){
  261.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] Parametri non Validi");
  262.         }
  263.         
  264.         Connection con = null;
  265.         PortaDelegata pd = null;
  266.         long idPortaDelegata = 0;
  267.         if (this.driver.atomica) {
  268.             try {
  269.                 con = this.driver.getConnectionFromDatasource("getPortaDelegata(idPortaDelegata)");

  271.             } catch (Exception e) {
  272.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] Exception accedendo al datasource :" + e.getMessage(),e);

  274.             }

  276.         } else
  277.             con = this.driver.globalConnection;

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

  281.         boolean trovato = false;
  282.         try {

  284.             try{
  285.                 idPortaDelegata = DBUtils.getIdPortaDelegata(nome, con, this.driver.tipoDB);
  286.             } catch (Exception se) {
  287.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] Exception: " + se.getMessage(),se);
  288.             }
  289.             if(idPortaDelegata>0){
  290.                 trovato = true;
  291.             }
  292.             
  293.         } catch (Exception se) {
  294.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] Exception: " + se.getMessage(),se);
  295.         } finally {

  297.             this.driver.closeConnection(con);
  298.         }

  300.         if (trovato) {
  301.             pd=this.driver.getPortaDelegata(idPortaDelegata);

  303.         } else {
  304.             throw new DriverConfigurazioneNotFound("PortaDelegata ["+nome+"] non esistente");
  305.         }

  307.         return pd;
  308.     }

  310.     protected void createPortaDelegata(PortaDelegata aPD) throws DriverConfigurazioneException {
  311.         if (aPD == null)
  312.             throw new DriverConfigurazioneException("Porta Delegata non valida");
  313.         if (aPD.getNome() == null || aPD.getNome().equals(""))
  314.             throw new DriverConfigurazioneException("Nome Porta Delegata non valido");
  315.         if (aPD.getNomeSoggettoProprietario() == null || aPD.getNomeSoggettoProprietario().equals(""))
  316.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Porta Delegata non valido");
  317.         if (aPD.getTipoSoggettoProprietario() == null || aPD.getTipoSoggettoProprietario().equals(""))
  318.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Porta Delegata non valido");
  319.         Connection con = null;
  320.         boolean error = false;

  322.         if (this.driver.atomica) {
  323.             try {
  324.                 con = this.driver.getConnectionFromDatasource("createPortaDelegata");
  325.                 con.setAutoCommit(false);
  326.             } catch (Exception e) {
  327.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createPortaDelegata] Exception accedendo al datasource :" + e.getMessage(),e);

  329.             }

  331.         } else
  332.             con = this.driver.globalConnection;

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

  336.         try {
  337.             this.driver.logDebug("CRUDPortaDelegata type = 1");

  339.             DriverConfigurazioneDB_porteDelegateLIB.CRUDPortaDelegata(1, aPD, con, this.driver.getDriverWrapBYOK());

  341.             this.driver.logDebug("Creazione PortaDelegata [" + aPD.getId() + "] completato.");

  343.         } catch (Exception qe) {
  344.             error = true;
  345.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createPortaDelegata] Errore durante la creazione della PortaDelegata : " + qe.getMessage(),qe);
  346.         } finally {

  348.             this.driver.closeConnection(error,con);
  349.         }
  350.     }
  351.     
  352.     protected void updatePortaDelegata(PortaDelegata aPD) throws DriverConfigurazioneException {
  353.         if (aPD == null)
  354.             throw new DriverConfigurazioneException("Porta Delegata non valida");
  355.         if (aPD.getNome() == null || aPD.getNome().equals(""))
  356.             throw new DriverConfigurazioneException("Nome Porta Delegata non valido");
  357.         if (aPD.getNomeSoggettoProprietario() == null || aPD.getNomeSoggettoProprietario().equals(""))
  358.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Porta Delegata non valido");
  359.         if (aPD.getTipoSoggettoProprietario() == null || aPD.getTipoSoggettoProprietario().equals(""))
  360.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Porta Delegata non valido");

  362.         Connection con = null;
  363.         boolean error = false;

  365.         if (this.driver.atomica) {
  366.             try {
  367.                 con = this.driver.getConnectionFromDatasource("updatePortaDelegata");
  368.                 con.setAutoCommit(false);
  369.             } catch (Exception e) {
  370.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updatePortaDelegata] Exception accedendo al datasource :" + e.getMessage(),e);

  372.             }

  374.         } else
  375.             con = this.driver.globalConnection;

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

  379.         try {
  380.             this.driver.logDebug("CRUDPortaDelegata type = 2");

  382.             DriverConfigurazioneDB_porteDelegateLIB.CRUDPortaDelegata(2, aPD, con, this.driver.getDriverWrapBYOK());

  384.             this.driver.logDebug("Aggiornamento PortaDelegata [" + aPD.getId() + "] completato.");

  386.         } catch (Exception qe) {
  387.             error = true;
  388.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updatePortaDelegata] Errore durante l'aggiornamento della PortaDelegata : " + qe.getMessage(),qe);
  389.         } finally {

  391.             this.driver.closeConnection(error,con);
  392.         }
  393.     }

  395.     protected void deletePortaDelegata(PortaDelegata aPD) throws DriverConfigurazioneException {
  396.         if (aPD == null)
  397.             throw new DriverConfigurazioneException("Porta Delegata non valida");
  398.         if (aPD.getNome() == null || aPD.getNome().equals(""))
  399.             throw new DriverConfigurazioneException("Nome Porta Delegata non valido");
  400.         if (aPD.getNomeSoggettoProprietario() == null || aPD.getNomeSoggettoProprietario().equals(""))
  401.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Porta Delegata non valido");
  402.         if (aPD.getTipoSoggettoProprietario() == null || aPD.getTipoSoggettoProprietario().equals(""))
  403.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Porta Delegata non valido");

  405.         Connection con = null;
  406.         boolean error = false;

  408.         if (this.driver.atomica) {
  409.             try {
  410.                 con = this.driver.getConnectionFromDatasource("deletePortaDelegata");
  411.                 con.setAutoCommit(false);
  412.             } catch (Exception e) {
  413.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deletePortaDelegata] Exception accedendo al datasource :" + e.getMessage(),e);

  415.             }

  417.         } else
  418.             con = this.driver.globalConnection;

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

  422.         try {
  423.             this.driver.logDebug("CRUDPortaDelegata type = 3");

  425.             long id = DriverConfigurazioneDB_porteDelegateLIB.CRUDPortaDelegata(3, aPD, con, this.driver.getDriverWrapBYOK());

  427.             this.driver.logDebug("Cancellazione PortaDelegata [" + id + "] completato.");
  428.         } catch (Exception qe) {
  429.             error = true;
  430.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deletePortaDelegata] Errore durante la cancellazione della PortaDelegata : " + qe.getMessage(),qe);
  431.         } finally {

  433.             this.driver.closeConnection(error,con);
  434.         }
  435.     }
  436.     
  437.     
  438.     protected PortaDelegata getPortaDelegata(long id) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  439.         return getPortaDelegata(id,null);
  440.     }
  441.     protected PortaDelegata getPortaDelegata(long id,Connection conParam) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {

  443.         if (id <= 0)
  444.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] L'id della Porta Delegata deve essere > 0.");

  446.         Connection con = null;
  447.         PreparedStatement stm = null;
  448.         ResultSet rs = null;
  449.         PreparedStatement stm1 = null;
  450.         ResultSet rs1 = null;
  451.         String sqlQuery;
  452.         PortaDelegata pd = null;
  453.         long idPortaDelegata = id;


  456.         if(conParam!=null){
  457.             con = conParam;
  458.         }
  459.         else  if (this.driver.atomica) {
  460.             try {
  461.                 con = this.driver.getConnectionFromDatasource("getPortaDelegata(longId)");

  463.             } catch (Exception e) {
  464.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] Exception accedendo al datasource :" + e.getMessage(),e);

  466.             }

  468.         } else
  469.             con = this.driver.globalConnection;

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

  473.         try {
  474.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  475.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  476.             sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  477.             sqlQueryObject.addSelectField("tipo_soggetto");
  478.             sqlQueryObject.addSelectField("nome_soggetto");
  479.             sqlQueryObject.addSelectField("autenticazione");
  480.             sqlQueryObject.addSelectField("autenticazione_opzionale");
  481.             sqlQueryObject.addSelectField("token_policy");
  482.             sqlQueryObject.addSelectField("token_opzionale");
  483.             sqlQueryObject.addSelectField("token_validazione");
  484.             sqlQueryObject.addSelectField("token_introspection");
  485.             sqlQueryObject.addSelectField("token_user_info");
  486.             sqlQueryObject.addSelectField("token_forward");
  487.             sqlQueryObject.addSelectField("token_options");
  488.             sqlQueryObject.addSelectField("token_authn_issuer");
  489.             sqlQueryObject.addSelectField("token_authn_client_id");
  490.             sqlQueryObject.addSelectField("token_authn_subject");
  491.             sqlQueryObject.addSelectField("token_authn_username");
  492.             sqlQueryObject.addSelectField("token_authn_email");
  493.             sqlQueryObject.addSelectField("autorizzazione");
  494.             sqlQueryObject.addSelectField("autorizzazione_xacml");
  495.             sqlQueryObject.addSelectField("autorizzazione_contenuto");
  496.             sqlQueryObject.addSelectField("id_soggetto");
  497.             sqlQueryObject.addSelectField("nome_porta");
  498.             sqlQueryObject.addSelectField("id_soggetto_erogatore");
  499.             sqlQueryObject.addSelectField("tipo_soggetto_erogatore");
  500.             sqlQueryObject.addSelectField("nome_soggetto_erogatore");
  501.             sqlQueryObject.addSelectField("id_servizio");
  502.             sqlQueryObject.addSelectField("tipo_servizio");
  503.             sqlQueryObject.addSelectField("nome_servizio");
  504.             sqlQueryObject.addSelectField("versione_servizio");
  505.             sqlQueryObject.addSelectField("id_azione");
  506.             sqlQueryObject.addSelectField("nome_azione");
  507.             sqlQueryObject.addSelectField("mode_azione");
  508.             sqlQueryObject.addSelectField("pattern_azione");
  509.             sqlQueryObject.addSelectField("nome_porta_delegante_azione");
  510.             sqlQueryObject.addSelectField("force_interface_based_azione");
  511.             sqlQueryObject.addSelectField("ricevuta_asincrona_asim");
  512.             sqlQueryObject.addSelectField("ricevuta_asincrona_sim");
  513.             sqlQueryObject.addSelectField("integrazione");
  514.             sqlQueryObject.addSelectField("scadenza_correlazione_appl");
  515.             sqlQueryObject.addSelectField("validazione_contenuti_stato");
  516.             sqlQueryObject.addSelectField("validazione_contenuti_tipo");
  517.             sqlQueryObject.addSelectField("validazione_contenuti_mtom");
  518.             sqlQueryObject.addSelectField("mtom_request_mode");
  519.             sqlQueryObject.addSelectField("mtom_response_mode");
  520.             sqlQueryObject.addSelectField("security");
  521.             sqlQueryObject.addSelectField("security_mtom_req");
  522.             sqlQueryObject.addSelectField("security_mtom_res");
  523.             sqlQueryObject.addSelectField("security_request_mode");
  524.             sqlQueryObject.addSelectField("security_response_mode");
  525.             sqlQueryObject.addSelectField("allega_body");
  526.             sqlQueryObject.addSelectField("scarta_body");
  527.             sqlQueryObject.addSelectField("gestione_manifest");
  528.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_DELEGATE+".descrizione", "descrizionePD");
  529.             sqlQueryObject.addSelectField("stateless");
  530.             sqlQueryObject.addSelectField("local_forward");
  531.             sqlQueryObject.addSelectField("local_forward_pa");
  532.             sqlQueryObject.addSelectField("ruoli_match");
  533.             sqlQueryObject.addSelectField("token_sa_stato");
  534.             sqlQueryObject.addSelectField("token_ruoli_stato");
  535.             sqlQueryObject.addSelectField("token_ruoli_match");
  536.             sqlQueryObject.addSelectField("token_ruoli_tipologia");
  537.             sqlQueryObject.addSelectField("scope_stato");
  538.             sqlQueryObject.addSelectField("scope_match");
  539.             sqlQueryObject.addSelectField("ricerca_porta_azione_delegata");
  540.             sqlQueryObject.addSelectField("msg_diag_severita");
  541.             sqlQueryObject.addSelectField("tracciamento_stato");
  542.             sqlQueryObject.addSelectField("tracciamento_esiti");
  543.             sqlQueryObject.addSelectField("transazioni_tempi");
  544.             sqlQueryObject.addSelectField("transazioni_token");
  545.             sqlQueryObject.addSelectField("stato");     
  546.             sqlQueryObject.addSelectField("cors_stato");
  547.             sqlQueryObject.addSelectField("cors_tipo");
  548.             sqlQueryObject.addSelectField("cors_all_allow_origins");
  549.             sqlQueryObject.addSelectField("cors_all_allow_methods");
  550.             sqlQueryObject.addSelectField("cors_all_allow_headers");
  551.             sqlQueryObject.addSelectField("cors_allow_credentials");
  552.             sqlQueryObject.addSelectField("cors_allow_max_age");
  553.             sqlQueryObject.addSelectField("cors_allow_max_age_seconds");
  554.             sqlQueryObject.addSelectField("cors_allow_origins");
  555.             sqlQueryObject.addSelectField("cors_allow_headers");
  556.             sqlQueryObject.addSelectField("cors_allow_methods");
  557.             sqlQueryObject.addSelectField("cors_allow_expose_headers");
  558.             sqlQueryObject.addSelectField("response_cache_stato");
  559.             sqlQueryObject.addSelectField("response_cache_seconds");
  560.             sqlQueryObject.addSelectField("response_cache_max_msg_size");
  561.             sqlQueryObject.addSelectField("response_cache_hash_url");
  562.             sqlQueryObject.addSelectField("response_cache_hash_query");
  563.             sqlQueryObject.addSelectField("response_cache_hash_query_list");
  564.             sqlQueryObject.addSelectField("response_cache_hash_headers");
  565.             sqlQueryObject.addSelectField("response_cache_hash_hdr_list");
  566.             sqlQueryObject.addSelectField("response_cache_hash_payload");
  567.             sqlQueryObject.addSelectField("response_cache_control_nocache");
  568.             sqlQueryObject.addSelectField("response_cache_control_maxage");
  569.             sqlQueryObject.addSelectField("response_cache_control_nostore");
  570.             sqlQueryObject.addSelectField("id_accordo");
  571.             sqlQueryObject.addSelectField("id_port_type");
  572.             sqlQueryObject.addSelectField("options");
  573.             sqlQueryObject.addSelectField("canale");
  574.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_DELEGATE,CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE,CostantiDB.PROPRIETA_OGGETTO_ALIAS_UTENTE_RICHIEDENTE);
  575.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_DELEGATE,CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE,CostantiDB.PROPRIETA_OGGETTO_ALIAS_DATA_CREAZIONE);
  576.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_DELEGATE,CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA,CostantiDB.PROPRIETA_OGGETTO_ALIAS_UTENTE_ULTIMA_MODIFICA);
  577.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_DELEGATE,CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA,CostantiDB.PROPRIETA_OGGETTO_ALIAS_DATA_ULTIMA_MODIFICA);
  578.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id_soggetto = "+this.driver.tabellaSoggetti+".id");
  579.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id = ?");
  580.             sqlQueryObject.setANDLogicOperator(true);
  581.             sqlQuery = sqlQueryObject.createSQLQuery();

  583.             stm = con.prepareStatement(sqlQuery);
  584.             stm.setLong(1, idPortaDelegata);

  586.             rs = stm.executeQuery();

  588.             if (rs.next()) {// ho trovato la porta delegata che cercavo

  590.                 pd = new PortaDelegata();

  592.                 pd.setOptions(rs.getString("options"));
  593.                 
  594.                 pd.setTipoSoggettoProprietario(rs.getString("tipo_soggetto"));
  595.                 pd.setNomeSoggettoProprietario(rs.getString("nome_soggetto"));

  597.                 pd.setId(idPortaDelegata);
  598.                 
  599.                 pd.setAutenticazione(rs.getString("autenticazione"));
  600.                 pd.setAutenticazioneOpzionale(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("autenticazione_opzionale")));
  601.                 
  602.                 String tokenPolicy = rs.getString("token_policy");
  603.                 if(tokenPolicy!=null && !"".equals(tokenPolicy)) {
  604.                     GestioneToken gestioneToken = new GestioneToken();
  605.                     gestioneToken.setPolicy(tokenPolicy);
  606.                     gestioneToken.setTokenOpzionale(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("token_opzionale")));
  607.                     gestioneToken.setValidazione(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(rs.getString("token_validazione")));
  608.                     gestioneToken.setIntrospection(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(rs.getString("token_introspection")));
  609.                     gestioneToken.setUserInfo(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(rs.getString("token_user_info")));
  610.                     gestioneToken.setForward(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("token_forward")));
  611.                     gestioneToken.setOptions(rs.getString("token_options"));
  612.                     
  613.                     
  614.                     String tokenAuthnIssuer = rs.getString("token_authn_issuer");
  615.                     String tokenAuthnClientId = rs.getString("token_authn_client_id");
  616.                     String tokenAuthnSubject = rs.getString("token_authn_subject");
  617.                     String tokenAuthnUsername = rs.getString("token_authn_username");
  618.                     String tokenAuthnEmail = rs.getString("token_authn_email");
  619.                     if(tokenAuthnIssuer!=null ||
  620.                             tokenAuthnClientId!=null ||
  621.                                     tokenAuthnSubject!=null ||
  622.                                             tokenAuthnUsername!=null ||
  623.                                                     tokenAuthnEmail!=null) {
  624.                         gestioneToken.setAutenticazione(new GestioneTokenAutenticazione());
  625.                         gestioneToken.getAutenticazione().setIssuer(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnIssuer));
  626.                         gestioneToken.getAutenticazione().setClientId(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnClientId));
  627.                         gestioneToken.getAutenticazione().setSubject(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnSubject));
  628.                         gestioneToken.getAutenticazione().setUsername(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnUsername));
  629.                         gestioneToken.getAutenticazione().setEmail(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnEmail));
  630.                     }
  631.                     
  632.                     pd.setGestioneToken(gestioneToken);
  633.                 }
  634.                 
  635.                 pd.setAutorizzazione(rs.getString("autorizzazione"));
  636.                 pd.setXacmlPolicy(rs.getString("autorizzazione_xacml"));
  637.                 pd.setAutorizzazioneContenuto(rs.getString("autorizzazione_contenuto"));

  639.                 pd.setDescrizione(rs.getString("descrizionePD"));
  640.                 pd.setIdSoggetto(rs.getLong("id_soggetto"));
  641.                 pd.setNome(rs.getString("nome_porta"));

  643.                 //idaccordo
  644.                 pd.setIdAccordo(rs.getLong("id_accordo"));
  645.                 //id port type
  646.                 pd.setIdPortType(rs.getLong("id_port_type"));

  648.                 //se mode e' settato allora creo oggetto
  649.                 String nomeSoggettoErogatore = rs.getString("nome_soggetto_erogatore");
  650.                 String tipoSoggettoErogatore = rs.getString("tipo_soggetto_erogatore");
  651.                 long idSoggettoErogatoreDB = rs.getLong("id_soggetto_erogatore");
  652.                 long idSoggErogatore=-1;
  653.                 if( (idSoggettoErogatoreDB==-2) || (idSoggettoErogatoreDB>0) ){
  654.                     idSoggErogatore = idSoggettoErogatoreDB;
  655.                 }
  656.                 else{
  657.                     try {
  658.                         idSoggErogatore = DBUtils.getIdSoggetto(nomeSoggettoErogatore, tipoSoggettoErogatore, con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  659.                     } catch (CoreException e) {
  660.                         this.driver.logDebug(e.getMessage(),e);
  661.                     }
  662.                 }
  663.                 PortaDelegataSoggettoErogatore soggettoErogatorePD = null;
  664.                 if(idSoggErogatore>0){
  665.                     soggettoErogatorePD = new PortaDelegataSoggettoErogatore();
  666.                     soggettoErogatorePD.setId(idSoggErogatore);
  667.                     soggettoErogatorePD.setNome(nomeSoggettoErogatore);
  668.                     soggettoErogatorePD.setTipo(tipoSoggettoErogatore);
  669.                     pd.setSoggettoErogatore(soggettoErogatorePD);
  670.                 }else{
  671.                     throw new DriverConfigurazioneException("Soggetto Erogatore della Porta Delegata ["+pd.getNome()+"] non presente.");
  672.                 }

  674.                 //se mode e' settato allora creo oggetto
  675.                 String tipoServizio = rs.getString("tipo_servizio");
  676.                 String nomeServizio = rs.getString("nome_servizio");
  677.                 Integer versioneServizio = rs.getInt("versione_servizio");
  678.                 long idServizioDB = rs.getLong("id_servizio");
  679.                 long idServizio=-1;
  680.                 if( (idServizioDB==-2) || (idServizioDB>0) ){
  681.                     idServizio = idServizioDB;
  682.                 }
  683.                 else{
  684.                     try {
  685.                         idServizio = DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeSoggettoErogatore, tipoSoggettoErogatore, con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  686.                     } catch (Exception e) {
  687.                         // NON Abilitare il log, poiche' la tabella servizi puo' non esistere per il driver di configurazione 
  688.                         // in un database che non ' quello della controlstation ma quello pdd.
  689.                         /**this.driver.logDebug(e);*/
  690.                     }
  691.                 }
  692.                 PortaDelegataServizio pdServizio = null;
  693.                 if(idServizio>0){
  694.                     pdServizio=new PortaDelegataServizio();
  695.                     pdServizio.setId(idServizio);
  696.                     pdServizio.setNome(nomeServizio);
  697.                     pdServizio.setTipo(tipoServizio);
  698.                     pdServizio.setVersione(versioneServizio);
  699.                 }
  700.                 // fix
  701.                 else {
  702.                     pdServizio=new PortaDelegataServizio();
  703.                     pdServizio.setNome(nomeServizio);
  704.                     pdServizio.setTipo(tipoServizio);
  705.                     pdServizio.setVersione(versioneServizio);
  706.                 }
  707.                 pd.setServizio(pdServizio);

  709.                 PortaDelegataAzione pdAzione = null;
  710.                 String modeAzione = rs.getString("mode_azione");
  711.                 long idAzione = rs.getLong("id_azione");
  712.                 if (idAzione>0 || (modeAzione!=null && !"".equals(modeAzione)) ) {
  713.                     pdAzione=new PortaDelegataAzione();
  714.                     pdAzione.setId(rs.getLong("id_azione"));
  715.                     pdAzione.setNome(rs.getString("nome_azione"));
  716.                     pdAzione.setIdentificazione(PortaDelegataAzioneIdentificazione.toEnumConstant(modeAzione));
  717.                     pdAzione.setPattern(rs.getString("pattern_azione"));
  718.                     pdAzione.setNomePortaDelegante(rs.getString("nome_porta_delegante_azione"));
  719.                     pdAzione.setForceInterfaceBased(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("force_interface_based_azione")));
  720.                 }
  721.                 pd.setAzione(pdAzione);






  728.                 //ricevuta asincrona_(a)simmetrica
  729.                 pd.setRicevutaAsincronaAsimmetrica(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("ricevuta_asincrona_asim")));
  730.                 pd.setRicevutaAsincronaSimmetrica(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("ricevuta_asincrona_sim")));
  731.                 //integrazione
  732.                 pd.setIntegrazione(rs.getString("integrazione"));
  733.                 //scadenza correlazione applicativa
  734.                 String scadenzaCorrelazione = rs.getString("scadenza_correlazione_appl");
  735.                 CorrelazioneApplicativa corr= null;

  737.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  738.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE);
  739.                 sqlQueryObject.addSelectField("*");
  740.                 sqlQueryObject.addWhereCondition("id_porta=?");
  741.                 sqlQueryObject.addOrderBy("id");
  742.                 sqlQueryObject.setSortType(true);
  743.                 String queryCorrApp = sqlQueryObject.createSQLQuery();
  744.                 PreparedStatement stmCorrApp = con.prepareStatement(queryCorrApp);
  745.                 stmCorrApp.setLong(1, idPortaDelegata);
  746.                 ResultSet rsCorrApp = stmCorrApp.executeQuery();
  747.                 while (rsCorrApp.next()) {
  748.                     if(corr==null) corr=new CorrelazioneApplicativa();
  749.                     CorrelazioneApplicativaElemento cae = new CorrelazioneApplicativaElemento();
  750.                     cae.setId(rsCorrApp.getLong("id"));
  751.                     cae.setNome(rsCorrApp.getString("nome_elemento"));
  752.                     String modeCA = rsCorrApp.getString("mode_correlazione");
  753.                     cae.setIdentificazione(DriverConfigurazioneDBLib.getEnumCorrelazioneApplicativaRichiestaIdentificazione(modeCA));
  754.                     /**if (modeCA.equals("urlBased") || modeCA.equals("contentBased"))*/
  755.                     cae.setPattern(rsCorrApp.getString("pattern"));
  756.                     cae.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumCorrelazioneApplicativaGestioneIdentificazioneFallita(rsCorrApp.getString("identificazione_fallita")));
  757.                     cae.setRiusoIdentificativo(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rsCorrApp.getString("riuso_id")));
  758.                     corr.addElemento(cae);
  759.                 }
  760.                 rsCorrApp.close();
  761.                 stmCorrApp.close();
  762.                 if(corr!=null && scadenzaCorrelazione!=null && !scadenzaCorrelazione.equals(""))
  763.                     corr.setScadenza(scadenzaCorrelazione);
  764.                 pd.setCorrelazioneApplicativa(corr);
  765.                 /**
  766.                   if(scadenzaCorrelazione!=null && !scadenzaCorrelazione.equals("")) {
  767.                   CorrelazioneApplicativa corr= new CorrelazioneApplicativa();
  768.                   corr.setScadenza(scadenzaCorrelazione);
  769.                   pd.setCorrelazioneApplicativa(corr);
  770.                   }
  771.                  */


  774.                 // correlazione applicativa risposta
  775.                 CorrelazioneApplicativaRisposta corrApplRisposta= null;

  777.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  778.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_CORRELAZIONE_RISPOSTA);
  779.                 sqlQueryObject.addSelectField("*");
  780.                 sqlQueryObject.addWhereCondition("id_porta=?");
  781.                 sqlQueryObject.addOrderBy("id");
  782.                 sqlQueryObject.setSortType(true);
  783.                 queryCorrApp = sqlQueryObject.createSQLQuery();
  784.                 stmCorrApp = con.prepareStatement(queryCorrApp);
  785.                 stmCorrApp.setLong(1, idPortaDelegata);
  786.                 rsCorrApp = stmCorrApp.executeQuery();
  787.                 while (rsCorrApp.next()) {
  788.                     if(corrApplRisposta==null) corrApplRisposta=new CorrelazioneApplicativaRisposta();
  789.                     CorrelazioneApplicativaRispostaElemento cae = new CorrelazioneApplicativaRispostaElemento();
  790.                     cae.setId(rsCorrApp.getLong("id"));
  791.                     cae.setNome(rsCorrApp.getString("nome_elemento"));
  792.                     String modeCA = rsCorrApp.getString("mode_correlazione");
  793.                     cae.setIdentificazione(DriverConfigurazioneDBLib.getEnumCorrelazioneApplicativaRispostaIdentificazione(modeCA));
  794.                     /**if (modeCA.equals("urlBased") || modeCA.equals("contentBased"))*/
  795.                     cae.setPattern(rsCorrApp.getString("pattern"));
  796.                     cae.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumCorrelazioneApplicativaGestioneIdentificazioneFallita(rsCorrApp.getString("identificazione_fallita")));
  797.                     corrApplRisposta.addElemento(cae);
  798.                 }
  799.                 rsCorrApp.close();
  800.                 stmCorrApp.close();
  801.                 pd.setCorrelazioneApplicativaRisposta(corrApplRisposta);

  803.                 
  804.                 //mtom
  805.                 MtomProcessor mtomProcessor = null;
  806.                 String mtomRequest = rs.getString("mtom_request_mode");
  807.                 String mtomResponse = rs.getString("mtom_response_mode");
  808.                 if( (mtomRequest!=null && !mtomRequest.equals(""))  ||  (mtomResponse!=null && !mtomResponse.equals("")) ){
  809.                     mtomProcessor = new MtomProcessor();
  810.                     if((mtomRequest!=null && !mtomRequest.equals(""))  ){
  811.                         mtomProcessor.setRequestFlow(new MtomProcessorFlow());
  812.                         mtomProcessor.getRequestFlow().setMode(DriverConfigurazioneDBLib.getEnumMTOMProcessorType(mtomRequest));
  813.                     }
  814.                     if((mtomResponse!=null && !mtomResponse.equals(""))  ){
  815.                         mtomProcessor.setResponseFlow(new MtomProcessorFlow());
  816.                         mtomProcessor.getResponseFlow().setMode(DriverConfigurazioneDBLib.getEnumMTOMProcessorType(mtomResponse));
  817.                     }
  818.                 }
  819.                 

  821.                 //validazione xsd
  822.                 String validazioneContenutiStato = rs.getString("validazione_contenuti_stato");
  823.                 String validazioneContenutiTipo = rs.getString("validazione_contenuti_tipo");
  824.                 String validazioneContenutiMtom = rs.getString("validazione_contenuti_mtom");
  825.                 if(  (validazioneContenutiStato!=null && !validazioneContenutiStato.equals(""))  
  826.                         ||
  827.                         (validazioneContenutiTipo!=null && !validazioneContenutiTipo.equals(""))    )
  828.                 {
  829.                     ValidazioneContenutiApplicativi val = new ValidazioneContenutiApplicativi();
  830.                     if((validazioneContenutiStato!=null && !validazioneContenutiStato.equals(""))  )
  831.                         val.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(validazioneContenutiStato));
  832.                     if((validazioneContenutiTipo!=null && !validazioneContenutiTipo.equals(""))  )
  833.                         val.setTipo(DriverConfigurazioneDBLib.getEnumValidazioneContenutiApplicativiTipo(validazioneContenutiTipo));
  834.                     if((validazioneContenutiMtom!=null && !validazioneContenutiMtom.equals(""))  )
  835.                         val.setAcceptMtomMessage(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(validazioneContenutiMtom));
  836.                     pd.setValidazioneContenutiApplicativi(val);
  837.                 }

  839.                 // Gestione funzionalita' Attachments
  840.                 pd.setAllegaBody(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("allega_body")));
  841.                 pd.setScartaBody(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("scarta_body")));
  842.                 pd.setGestioneManifest(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("gestione_manifest")));

  844.                 // Stateless
  845.                 pd.setStateless(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("stateless")));

  847.                 // LocalForward
  848.                 String statoLocalForward = rs.getString("local_forward");
  849.                 PortaDelegataLocalForward pdLocalForward = new PortaDelegataLocalForward();
  850.                 pdLocalForward.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(statoLocalForward));
  851.                 pdLocalForward.setPortaApplicativa(rs.getString("local_forward_pa"));
  852.                 if(pdLocalForward.getStato()!=null) {
  853.                     pd.setLocalForward(pdLocalForward);
  854.                 }
  855.                 else {
  856.                     pd.setLocalForward(null);
  857.                 }
  858.                 
  859.                 // Ricerca Porta Azione Delegata
  860.                 if(rs.getString("ricerca_porta_azione_delegata")!=null){
  861.                     pd.setRicercaPortaAzioneDelegata(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("ricerca_porta_azione_delegata")));
  862.                 }
  863.                 
  864.                 // Tracciamento
  865.                 String msgDiagSeverita = rs.getString("msg_diag_severita");
  866.                 String tracciamentoStato = rs.getString("tracciamento_stato");
  867.                 String tracciamentoEsiti = rs.getString("tracciamento_esiti");
  868.                 String transazioniTempiElaborazione = rs.getString("transazioni_tempi");
  869.                 String transazioniToken = rs.getString("transazioni_token");
  870.                 TracciamentoConfigurazione tracciamentoDatabase = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, pd.getId(), 
  871.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD,
  872.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  873.                 TracciamentoConfigurazione tracciamentoFiletrace = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, pd.getId(), 
  874.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD,
  875.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  876.                 TracciamentoConfigurazioneFiletrace tracciamentoFiletraceDetails = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazioneFiletrace(con, pd.getId(), 
  877.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD);
  878.                 if( 
  879.                         (msgDiagSeverita!=null && StringUtils.isNotEmpty(msgDiagSeverita))
  880.                         ||
  881.                         (tracciamentoStato!=null && StringUtils.isNotEmpty(tracciamentoStato))
  882.                         ||
  883.                         (tracciamentoEsiti!=null && StringUtils.isNotEmpty(tracciamentoEsiti))
  884.                         ||
  885.                         (transazioniTempiElaborazione!=null && StringUtils.isNotEmpty(transazioniTempiElaborazione))
  886.                         ||
  887.                         (transazioniToken!=null && StringUtils.isNotEmpty(transazioniToken))
  888.                         ||
  889.                         tracciamentoDatabase!=null
  890.                         ||
  891.                         tracciamentoFiletrace!=null
  892.                         ||
  893.                         tracciamentoFiletraceDetails!=null
  894.                         ) {
  895.                     PortaTracciamento tracciamento = new PortaTracciamento();
  896.                     
  897.                     tracciamento.setSeverita(DriverConfigurazioneDBLib.getEnumSeverita(msgDiagSeverita));
  898.                     
  899.                     tracciamento.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tracciamentoStato));
  900.                     
  901.                     tracciamento.setEsiti(tracciamentoEsiti);
  902.                     
  903.                     if( 
  904.                             (transazioniTempiElaborazione!=null && StringUtils.isNotEmpty(transazioniTempiElaborazione))
  905.                             ||
  906.                             (transazioniToken!=null && StringUtils.isNotEmpty(transazioniToken))
  907.                             ) {
  908.                         tracciamento.setTransazioni(new Transazioni());
  909.                         tracciamento.getTransazioni().setTempiElaborazione(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(transazioniTempiElaborazione));
  910.                         tracciamento.getTransazioni().setToken(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(transazioniToken));
  911.                     }
  912.                     tracciamento.setDatabase(tracciamentoDatabase);
  913.                     tracciamento.setFiletrace(tracciamentoFiletrace);
  914.                     tracciamento.setFiletraceConfig(tracciamentoFiletraceDetails);
  915.                     
  916.                     pd.setTracciamento(tracciamento);
  917.                 }
  918.                 
  919.                 // Stato
  920.                 if(rs.getString("stato")!=null){
  921.                     pd.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("stato")));
  922.                 }
  923.                 

  925.                 // messageSecurity          
  926.                 String security = rs.getString("security");
  927.                 String securityMtomReq = rs.getString("security_mtom_req");
  928.                 String securityMtomRes = rs.getString("security_mtom_res");
  929.                 String securityRequestMode = rs.getString("security_request_mode");
  930.                 String securityResponseMode = rs.getString("security_response_mode");
  931.                 MessageSecurity messageSecurity = null;
  932.                 if(  (securityMtomReq!=null && !securityMtomReq.equals(""))  
  933.                         ||
  934.                         (securityRequestMode!=null && !securityRequestMode.equals(""))  
  935.                         ||
  936.                         (securityMtomRes!=null && !securityMtomRes.equals(""))      
  937.                         ||
  938.                         (securityResponseMode!=null && !securityResponseMode.equals("")) 
  939.                         )
  940.                 {
  941.                     messageSecurity = new MessageSecurity();
  942.                     if((securityMtomReq!=null && !securityMtomReq.equals(""))  ){
  943.                         if(messageSecurity.getRequestFlow()==null) {
  944.                             messageSecurity.setRequestFlow(new MessageSecurityFlow());  
  945.                         }
  946.                         messageSecurity.getRequestFlow().setApplyToMtom(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(securityMtomReq));
  947.                     }
  948.                     if((securityMtomRes!=null && !securityMtomRes.equals(""))  ){
  949.                         if(messageSecurity.getResponseFlow()==null) {
  950.                             messageSecurity.setResponseFlow(new MessageSecurityFlow()); 
  951.                         }
  952.                         messageSecurity.getResponseFlow().setApplyToMtom(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(securityMtomRes));
  953.                     }
  954.                     if((securityRequestMode!=null && !securityRequestMode.equals(""))  ){
  955.                         if(messageSecurity.getRequestFlow()==null) {
  956.                             messageSecurity.setRequestFlow(new MessageSecurityFlow());  
  957.                         }
  958.                         messageSecurity.getRequestFlow().setMode(securityRequestMode);
  959.                     }
  960.                     if((securityResponseMode!=null && !securityResponseMode.equals(""))  ){
  961.                         if(messageSecurity.getResponseFlow()==null) {
  962.                             messageSecurity.setResponseFlow(new MessageSecurityFlow()); 
  963.                         }
  964.                         messageSecurity.getResponseFlow().setMode(securityResponseMode);
  965.                     }
  966.                 }

  968.                 
  969.                 // RuoliMatch
  970.                 String ruoliMatch = rs.getString("ruoli_match");
  971.                 if(ruoliMatch!=null && !"".equals(ruoliMatch)){
  972.                     if(pd.getRuoli()==null){
  973.                         pd.setRuoli(new AutorizzazioneRuoli());
  974.                     }
  975.                     pd.getRuoli().setMatch(RuoloTipoMatch.toEnumConstant(ruoliMatch));
  976.                 }
  977.                 
  978.                 // Token SA Stato
  979.                 String tokenSaStato = rs.getString("token_sa_stato");
  980.                 if( (tokenSaStato!=null && !"".equals(tokenSaStato)) ){
  981.                     if(pd.getAutorizzazioneToken()==null){
  982.                         pd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  983.                     }
  984.                     pd.getAutorizzazioneToken().setAutorizzazioneApplicativi((DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenSaStato)));
  985.                 }
  986.                 
  987.                 // Token Ruoli
  988.                 String tokenRuoliStato = rs.getString("token_ruoli_stato");
  989.                 String tokenRuoliMatch = rs.getString("token_ruoli_match");
  990.                 String tokenRuoliTipologia = rs.getString("token_ruoli_tipologia");
  991.                 if( (tokenRuoliStato!=null && !"".equals(tokenRuoliStato)) ||
  992.                         (tokenRuoliMatch!=null && !"".equals(tokenRuoliMatch)) ||
  993.                         (tokenRuoliTipologia!=null && !"".equals(tokenRuoliTipologia)) ){
  994.                     if(pd.getAutorizzazioneToken()==null){
  995.                         pd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  996.                     }
  997.                     pd.getAutorizzazioneToken().setAutorizzazioneRuoli(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenRuoliStato));
  998.                     if((tokenRuoliMatch!=null && !"".equals(tokenRuoliMatch))) {
  999.                         if(pd.getAutorizzazioneToken().getRuoli()==null){
  1000.                             pd.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  1001.                         }
  1002.                         pd.getAutorizzazioneToken().getRuoli().setMatch(RuoloTipoMatch.toEnumConstant(tokenRuoliMatch));
  1003.                     }
  1004.                     if((tokenRuoliTipologia!=null && !"".equals(tokenRuoliTipologia))) {
  1005.                         pd.getAutorizzazioneToken().setTipologiaRuoli(RuoloTipologia.toEnumConstant(tokenRuoliTipologia));
  1006.                     }
  1007.                 }
  1008.                 
  1009.                 // ScopeMatch
  1010.                 String scopeStato = rs.getString("scope_stato");
  1011.                 String scopeMatch = rs.getString("scope_match");
  1012.                 if( (scopeStato!=null && !"".equals(scopeStato)) || (scopeMatch!=null && !"".equals(scopeMatch)) ){
  1013.                     if(pd.getScope()==null){
  1014.                         pd.setScope(new AutorizzazioneScope());
  1015.                     }
  1016.                     pd.getScope().setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(scopeStato));
  1017.                     pd.getScope().setMatch(ScopeTipoMatch.toEnumConstant(scopeMatch));
  1018.                 }
  1019.                 
  1020.                 // Gestione CORS
  1021.                 String corsStato = rs.getString("cors_stato");
  1022.                 if(corsStato!=null && !"".equals(corsStato)) {
  1023.                     pd.setGestioneCors(new CorsConfigurazione());
  1024.                     this.porteDriver.readConfigurazioneCors(pd.getGestioneCors(), rs);
  1025.                 }
  1026.                 
  1027.                 // Gestione CacheResponse
  1028.                 String responseCacheStato = rs.getString("response_cache_stato");
  1029.                 if(responseCacheStato!=null && !"".equals(responseCacheStato)) {
  1030.                     pd.setResponseCaching(new ResponseCachingConfigurazione());
  1031.                     this.porteDriver.readResponseCaching(idPortaDelegata, false, true, pd.getResponseCaching(), rs, con);
  1032.                 }
  1033.                 
  1034.                 // Canali
  1035.                 String canale = rs.getString("canale");
  1036.                 pd.setCanale(canale);
  1037.                 
  1038.                 // Proprieta Oggetto
  1039.                 pd.setProprietaOggetto(this.utilsDriver.readProprietaOggetto(rs, true));
  1040.                 
  1041.                 rs.close();
  1042.                 stm.close();
  1043.                         
  1044.                 
  1045.                 // Trasformazioni
  1046.                 Trasformazioni trasformazioni = DriverConfigurazioneDBTrasformazioniLib.readTrasformazioni(idPortaDelegata, true, con);
  1047.                 if(trasformazioni!=null) {
  1048.                     pd.setTrasformazioni(trasformazioni);
  1049.                 }

  1051.                 
  1052.                 if(pdAzione!=null) {
  1053.                     // lista azioni
  1054.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1055.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  1056.                     sqlQueryObject.addSelectField("*");
  1057.                     sqlQueryObject.addWhereCondition("id_porta=?");
  1058.                     sqlQuery = sqlQueryObject.createSQLQuery();
  1059.                     stm = con.prepareStatement(sqlQuery);
  1060.                     stm.setLong(1, idPortaDelegata);

  1062.                     this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaDelegata));
  1063.                     rs = stm.executeQuery();

  1065.                     // Request Flow Parameter
  1066.                     while (rs.next()) {
  1067.                         pdAzione.addAzioneDelegata(rs.getString("azione"));
  1068.                     }
  1069.                     rs.close();
  1070.                     stm.close();
  1071.                 }
  1072.                 
  1073.                 
  1074.                 
  1075.                 // stato security
  1076.                 if (CostantiConfigurazione.ABILITATO.toString().equalsIgnoreCase(security)) {
  1077.                     pd.setStatoMessageSecurity(CostantiConfigurazione.ABILITATO.toString());
  1078.                 }else{
  1079.                     pd.setStatoMessageSecurity(CostantiConfigurazione.DISABILITATO.toString());
  1080.                 }
  1081.                 
  1082.                 // lista wss
  1083.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1084.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_REQUEST);
  1085.                 sqlQueryObject.addSelectField("*");
  1086.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1087.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1088.                 stm = con.prepareStatement(sqlQuery);
  1089.                 stm.setLong(1, idPortaDelegata);

  1091.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaDelegata));
  1092.                 rs = stm.executeQuery();

  1094.                 // Request Flow Parameter
  1095.                 MessageSecurityFlowParameter secRfp;
  1096.                 while (rs.next()) {
  1097.                     secRfp = new MessageSecurityFlowParameter();
  1098.                     secRfp.setNome(rs.getString("nome"));
  1099.                     
  1100.                     String plainValue = rs.getString("valore");
  1101.                     String encValue = rs.getString("enc_value");
  1102.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1103.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1104.                         if(driverBYOK!=null) {
  1105.                             secRfp.setValore(driverBYOK.unwrapAsString(encValue));
  1106.                         }
  1107.                         else {
  1108.                             secRfp.setValore(encValue);
  1109.                         }
  1110.                     }
  1111.                     else {
  1112.                         secRfp.setValore(plainValue);
  1113.                     }
  1114.                     
  1115.                     if(messageSecurity==null){
  1116.                         messageSecurity = new MessageSecurity();
  1117.                     }
  1118.                     if(messageSecurity.getRequestFlow()==null){
  1119.                         messageSecurity.setRequestFlow(new MessageSecurityFlow());
  1120.                     }
  1121.                     messageSecurity.getRequestFlow().addParameter(secRfp);
  1122.                 }
  1123.                 rs.close();
  1124.                 stm.close();
  1125.                 // Response Flow Parameter
  1126.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1127.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_MESSAGE_SECURITY_RESPONSE);
  1128.                 sqlQueryObject.addSelectField("*");
  1129.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1130.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1131.                 stm = con.prepareStatement(sqlQuery);
  1132.                 stm.setLong(1, idPortaDelegata);

  1134.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaDelegata));
  1135.                 rs = stm.executeQuery();

  1137.                 MessageSecurityFlowParameter secResfp;
  1138.                 while (rs.next()) {
  1139.                     secResfp = new MessageSecurityFlowParameter();
  1140.                     secResfp.setNome(rs.getString("nome"));
  1141.                     
  1142.                     String plainValue = rs.getString("valore");
  1143.                     String encValue = rs.getString("enc_value");
  1144.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1145.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1146.                         if(driverBYOK!=null) {
  1147.                             secResfp.setValore(driverBYOK.unwrapAsString(encValue));
  1148.                         }
  1149.                         else {
  1150.                             secResfp.setValore(encValue);
  1151.                         }
  1152.                     }
  1153.                     else {
  1154.                         secResfp.setValore(plainValue);
  1155.                     }
  1156.                     
  1157.                     if(messageSecurity==null){
  1158.                         messageSecurity = new MessageSecurity();
  1159.                     }
  1160.                     if(messageSecurity.getResponseFlow()==null){
  1161.                         messageSecurity.setResponseFlow(new MessageSecurityFlow());
  1162.                     }
  1163.                     messageSecurity.getResponseFlow().addParameter(secResfp);
  1164.                 }
  1165.                 rs.close();
  1166.                 stm.close();


  1169.                 // setto il messageSecurity
  1170.                 pd.setMessageSecurity(messageSecurity);

  1172.                 
  1173.                 
  1174.                 // mtom
  1175.                 
  1176.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1177.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_MTOM_REQUEST);
  1178.                 sqlQueryObject.addSelectField("*");
  1179.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1180.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1181.                 stm1 = con.prepareStatement(sqlQuery);
  1182.                 stm1.setLong(1, idPortaDelegata);

  1184.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaDelegata));
  1185.                 rs1 = stm1.executeQuery();

  1187.                 // Request Flow Parameter
  1188.                 MtomProcessorFlowParameter rfp;
  1189.                 while (rs1.next()) {
  1190.                     rfp = new MtomProcessorFlowParameter();
  1191.                     rfp.setNome(rs1.getString("nome"));
  1192.                     rfp.setPattern(rs1.getString("pattern"));
  1193.                     rfp.setContentType(rs1.getString("content_type"));
  1194.                     int required = rs1.getInt("required");
  1195.                     boolean isrequired = false;
  1196.                     if (required == CostantiDB.TRUE)
  1197.                         isrequired = true;
  1198.                     rfp.setRequired(isrequired);
  1199.                     
  1200.                     if(mtomProcessor.getRequestFlow()==null){
  1201.                         mtomProcessor.setRequestFlow(new MtomProcessorFlow());
  1202.                     }
  1203.                     mtomProcessor.getRequestFlow().addParameter(rfp);
  1204.                 }
  1205.                 rs1.close();
  1206.                 stm1.close();

  1208.                 // Response Flow Parameter
  1209.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1210.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_MTOM_RESPONSE);
  1211.                 sqlQueryObject.addSelectField("*");
  1212.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1213.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1214.                 stm1 = con.prepareStatement(sqlQuery);
  1215.                 stm1.setLong(1, idPortaDelegata);

  1217.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaDelegata));
  1218.                 rs1 = stm1.executeQuery();

  1220.                 MtomProcessorFlowParameter rsfp;
  1221.                 while (rs1.next()) {
  1222.                     rsfp = new MtomProcessorFlowParameter();
  1223.                     rsfp.setNome(rs1.getString("nome"));
  1224.                     rsfp.setPattern(rs1.getString("pattern"));
  1225.                     rsfp.setContentType(rs1.getString("content_type"));
  1226.                     int required = rs1.getInt("required");
  1227.                     boolean isrequired = false;
  1228.                     if (required == CostantiDB.TRUE)
  1229.                         isrequired = true;
  1230.                     rsfp.setRequired(isrequired);
  1231.                     
  1232.                     if(mtomProcessor.getResponseFlow()==null){
  1233.                         mtomProcessor.setResponseFlow(new MtomProcessorFlow());
  1234.                     }
  1235.                     mtomProcessor.getResponseFlow().addParameter(rsfp);
  1236.                 }
  1237.                 rs1.close();
  1238.                 stm1.close();
  1239.                 
  1240.                 // set mtom
  1241.                 pd.setMtomProcessor(mtomProcessor);
  1242.                 
  1243.                 
  1244.                 // servizi applicativi
  1245.                 long idSA = 0;
  1246.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1247.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_SA);
  1248.                 sqlQueryObject.addSelectField("*");
  1249.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1250.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1251.                 stm = con.prepareStatement(sqlQuery);
  1252.                 stm.setLong(1, idPortaDelegata);
  1253.                 rs = stm.executeQuery();

  1255.                 // per ogni entry con id_porta == idPortaDelegata
  1256.                 // prendo l'id del servizio applicativo associato, recupero il
  1257.                 // nome e aggiungo
  1258.                 // il servizio applicativo alla PortaDelegata da ritornare
  1259.                 while (rs.next()) {
  1260.                     idSA = rs.getLong("id_servizio_applicativo");

  1262.                     if (idSA != 0) {
  1263.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1264.                         sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1265.                         sqlQueryObject.addSelectField("nome");
  1266.                         sqlQueryObject.addWhereCondition("id=?");
  1267.                         sqlQuery = sqlQueryObject.createSQLQuery();
  1268.                         stm1 = con.prepareStatement(sqlQuery);
  1269.                         stm1.setLong(1, idSA);

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

  1273.                         rs1 = stm1.executeQuery();

  1275.                         PortaDelegataServizioApplicativo servizioApplicativo = null;
  1276.                         if (rs1.next()) {
  1277.                             // setto solo il nome come da specifica
  1278.                             servizioApplicativo = new PortaDelegataServizioApplicativo();
  1279.                             servizioApplicativo.setId(idSA);
  1280.                             servizioApplicativo.setNome(rs1.getString("nome"));
  1281.                             pd.addServizioApplicativo(servizioApplicativo);
  1282.                         }
  1283.                         rs1.close();
  1284.                         stm1.close();
  1285.                     }

  1287.                 }
  1288.                 rs.close();
  1289.                 stm.close();
  1290.                 
  1291.                 
  1292.                 // proprieta autenticazione
  1293.                 Proprieta prop = null;
  1294.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1295.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AUTENTICAZIONE_PROP);
  1296.                 sqlQueryObject.addSelectField("*");
  1297.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1298.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1299.                 stm = con.prepareStatement(sqlQuery);
  1300.                 stm.setLong(1, idPortaDelegata);
  1301.                 rs=stm.executeQuery();
  1302.                 while (rs.next()) {
  1303.                     prop = new Proprieta();
  1304.                     prop.setId(rs.getLong("id"));
  1305.                     prop.setNome(rs.getString("nome"));
  1306.                     
  1307.                     String plainValue = rs.getString("valore");
  1308.                     String encValue = rs.getString("enc_value");
  1309.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1310.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1311.                         if(driverBYOK!=null) {
  1312.                             prop.setValore(driverBYOK.unwrapAsString(encValue));
  1313.                         }
  1314.                         else {
  1315.                             prop.setValore(encValue);
  1316.                         }
  1317.                     }
  1318.                     else {
  1319.                         prop.setValore(plainValue);
  1320.                     }
  1321.                     
  1322.                     pd.addProprietaAutenticazione(prop);
  1323.                 }
  1324.                 rs.close();
  1325.                 stm.close();
  1326.                 
  1327.                 
  1328.                 
  1329.                 
  1330.                 // proprieta autorizzazione
  1331.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1332.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_PROP);
  1333.                 sqlQueryObject.addSelectField("*");
  1334.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1335.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1336.                 stm = con.prepareStatement(sqlQuery);
  1337.                 stm.setLong(1, idPortaDelegata);
  1338.                 rs=stm.executeQuery();
  1339.                 while (rs.next()) {
  1340.                     prop = new Proprieta();
  1341.                     prop.setId(rs.getLong("id"));
  1342.                     prop.setNome(rs.getString("nome"));
  1343.                     
  1344.                     String plainValue = rs.getString("valore");
  1345.                     String encValue = rs.getString("enc_value");
  1346.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1347.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1348.                         if(driverBYOK!=null) {
  1349.                             prop.setValore(driverBYOK.unwrapAsString(encValue));
  1350.                         }
  1351.                         else {
  1352.                             prop.setValore(encValue);
  1353.                         }
  1354.                     }
  1355.                     else {
  1356.                         prop.setValore(plainValue);
  1357.                     }
  1358.                     
  1359.                     pd.addProprietaAutorizzazione(prop);
  1360.                 }
  1361.                 rs.close();
  1362.                 stm.close();
  1363.                 
  1364.                 
  1365.                 
  1366.                 // proprieta autorizzazione contenuto
  1367.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1368.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AUTORIZZAZIONE_CONTENUTI_PROP);
  1369.                 sqlQueryObject.addSelectField("*");
  1370.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1371.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1372.                 stm = con.prepareStatement(sqlQuery);
  1373.                 stm.setLong(1, idPortaDelegata);
  1374.                 rs=stm.executeQuery();
  1375.                 while (rs.next()) {
  1376.                     prop = new Proprieta();
  1377.                     prop.setId(rs.getLong("id"));
  1378.                     prop.setNome(rs.getString("nome"));
  1379.                     
  1380.                     String plainValue = rs.getString("valore");
  1381.                     String encValue = rs.getString("enc_value");
  1382.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1383.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1384.                         if(driverBYOK!=null) {
  1385.                             prop.setValore(driverBYOK.unwrapAsString(encValue));
  1386.                         }
  1387.                         else {
  1388.                             prop.setValore(encValue);
  1389.                         }
  1390.                     }
  1391.                     else {
  1392.                         prop.setValore(plainValue);
  1393.                     }
  1394.                     
  1395.                     pd.addProprietaAutorizzazioneContenuto(prop);
  1396.                 }
  1397.                 rs.close();
  1398.                 stm.close();
  1399.                 
  1400.                 
  1401.                 
  1402.                 
  1403.                 
  1404.                 // proprieta rate limiting
  1405.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1406.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_RATE_LIMITING_PROP);
  1407.                 sqlQueryObject.addSelectField("*");
  1408.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1409.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1410.                 stm = con.prepareStatement(sqlQuery);
  1411.                 stm.setLong(1, idPortaDelegata);
  1412.                 rs=stm.executeQuery();
  1413.                 while (rs.next()) {
  1414.                     prop = new Proprieta();
  1415.                     prop.setId(rs.getLong("id"));
  1416.                     prop.setNome(rs.getString("nome"));
  1417.                     prop.setValore(rs.getString("valore"));
  1418.                     pd.addProprietaRateLimiting(prop);
  1419.                 }
  1420.                 rs.close();
  1421.                 stm.close();
  1422.                 
  1423.                 
  1424.                 
  1425.                 
  1426.                 // properties
  1427.                 prop = null;
  1428.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1429.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_PROP);
  1430.                 sqlQueryObject.addSelectField("*");
  1431.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1432.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1433.                 stm = con.prepareStatement(sqlQuery);
  1434.                 stm.setLong(1, idPortaDelegata);
  1435.                 rs=stm.executeQuery();
  1436.                 while (rs.next()) {
  1437.                     prop = new Proprieta();
  1438.                     prop.setId(rs.getLong("id"));
  1439.                     prop.setNome(rs.getString("nome"));
  1440.                     
  1441.                     String plainValue = rs.getString("valore");
  1442.                     String encValue = rs.getString("enc_value");
  1443.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1444.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1445.                         if(driverBYOK!=null) {
  1446.                             prop.setValore(driverBYOK.unwrapAsString(encValue));
  1447.                         }
  1448.                         else {
  1449.                             prop.setValore(encValue);
  1450.                         }
  1451.                     }
  1452.                     else {
  1453.                         prop.setValore(plainValue);
  1454.                     }
  1455.                     
  1456.                     pd.addProprieta(prop);
  1457.                 }
  1458.                 rs.close();
  1459.                 stm.close();
  1460.                 
  1461.                             
  1462.                 // ruoli
  1463.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1464.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_RUOLI);
  1465.                 sqlQueryObject.addSelectField("*");
  1466.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1467.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1468.                 stm = con.prepareStatement(sqlQuery);
  1469.                 stm.setLong(1, idPortaDelegata);
  1470.                 rs = stm.executeQuery();

  1472.                 while (rs.next()) {
  1473.                     
  1474.                     if(pd.getRuoli()==null){
  1475.                         pd.setRuoli(new AutorizzazioneRuoli());
  1476.                     }
  1477.                     
  1478.                     Ruolo ruolo = new Ruolo();
  1479.                     ruolo.setNome(rs.getString("ruolo"));
  1480.                     pd.getRuoli().addRuolo(ruolo);
  1481.                 
  1482.                 }
  1483.                 rs.close();
  1484.                 stm.close();
  1485.                 
  1486.                 
  1487.                 
  1488.                 // scope
  1489.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1490.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_SCOPE);
  1491.                 sqlQueryObject.addSelectField("*");
  1492.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1493.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1494.                 stm = con.prepareStatement(sqlQuery);
  1495.                 stm.setLong(1, idPortaDelegata);
  1496.                 rs = stm.executeQuery();

  1498.                 while (rs.next()) {
  1499.                     
  1500.                     if(pd.getScope()==null){
  1501.                         pd.setScope(new AutorizzazioneScope());
  1502.                     }
  1503.                     
  1504.                     Scope scope = new Scope();
  1505.                     scope.setNome(rs.getString("scope"));
  1506.                     pd.getScope().addScope(scope);
  1507.                 
  1508.                 }
  1509.                 rs.close();
  1510.                 stm.close();
  1511.                 
  1512.                 
  1513.                 // servizi applicativi (token)
  1514.                 idSA = 0;
  1515.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1516.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  1517.                 sqlQueryObject.addSelectField("*");
  1518.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1519.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1520.                 stm = con.prepareStatement(sqlQuery);
  1521.                 stm.setLong(1, idPortaDelegata);
  1522.                 rs = stm.executeQuery();

  1524.                 // per ogni entry con id_porta == idPortaDelegata
  1525.                 // prendo l'id del servizio applicativo associato, recupero il
  1526.                 // nome e aggiungo
  1527.                 // il servizio applicativo alla PortaDelegata da ritornare
  1528.                 while (rs.next()) {
  1529.                     idSA = rs.getLong("id_servizio_applicativo");

  1531.                     if (idSA != 0) {
  1532.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1533.                         sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1534.                         sqlQueryObject.addSelectField("nome");
  1535.                         sqlQueryObject.addWhereCondition("id=?");
  1536.                         sqlQuery = sqlQueryObject.createSQLQuery();
  1537.                         stm1 = con.prepareStatement(sqlQuery);
  1538.                         stm1.setLong(1, idSA);

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

  1542.                         rs1 = stm1.executeQuery();

  1544.                         PortaDelegataServizioApplicativo servizioApplicativo = null;
  1545.                         if (rs1.next()) {
  1546.                             // setto solo il nome come da specifica
  1547.                             servizioApplicativo = new PortaDelegataServizioApplicativo();
  1548.                             servizioApplicativo.setId(idSA);
  1549.                             servizioApplicativo.setNome(rs1.getString("nome"));
  1550.                             
  1551.                             if(pd.getAutorizzazioneToken()==null) {
  1552.                                 pd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  1553.                             }
  1554.                             if(pd.getAutorizzazioneToken().getServiziApplicativi()==null) {
  1555.                                 pd.getAutorizzazioneToken().setServiziApplicativi(new PortaDelegataAutorizzazioneServiziApplicativi());
  1556.                             }
  1557.                             
  1558.                             pd.getAutorizzazioneToken().getServiziApplicativi().addServizioApplicativo(servizioApplicativo);
  1559.                         }
  1560.                         rs1.close();
  1561.                         stm1.close();
  1562.                     }

  1564.                 }
  1565.                 rs.close();
  1566.                 stm.close();
  1567.                 
  1568.                 
  1569.                 // ruoli (token)
  1570.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1571.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI);
  1572.                 sqlQueryObject.addSelectField("*");
  1573.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1574.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1575.                 stm = con.prepareStatement(sqlQuery);
  1576.                 stm.setLong(1, idPortaDelegata);
  1577.                 rs = stm.executeQuery();

  1579.                 while (rs.next()) {
  1580.                     
  1581.                     if(pd.getAutorizzazioneToken()==null) {
  1582.                         pd.setAutorizzazioneToken(new PortaDelegataAutorizzazioneToken());
  1583.                     }
  1584.                     if(pd.getAutorizzazioneToken().getRuoli()==null) {
  1585.                         pd.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  1586.                     }
  1587.                     
  1588.                     Ruolo ruolo = new Ruolo();
  1589.                     ruolo.setNome(rs.getString("ruolo"));
  1590.                     pd.getAutorizzazioneToken().getRuoli().addRuolo(ruolo);
  1591.                 
  1592.                 }
  1593.                 rs.close();
  1594.                 stm.close();
  1595.                 
  1596.                 
  1597.                 
  1598.                 // dump_config
  1599.                 DumpConfigurazione dumpConfig = DriverConfigurazioneDB_dumpLIB.readDumpConfigurazione(con, pd.getId(), CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_PD);
  1600.                 pd.setDump(dumpConfig);
  1601.                 
  1602.                 
  1603.                 // Handlers
  1604.                 ConfigurazioneMessageHandlers requestHandlers = DriverConfigurazioneDB_handlerLIB.readConfigurazioneMessageHandlers(con, pd.getId(), null, true);
  1605.                 ConfigurazioneMessageHandlers responseHandlers = DriverConfigurazioneDB_handlerLIB.readConfigurazioneMessageHandlers(con, pd.getId(), null, false);
  1606.                 if(requestHandlers!=null || responseHandlers!=null) {
  1607.                     pd.setConfigurazioneHandler(new ConfigurazionePortaHandler());
  1608.                     pd.getConfigurazioneHandler().setRequest(requestHandlers);
  1609.                     pd.getConfigurazioneHandler().setResponse(responseHandlers);
  1610.                 }

  1612.                 
  1613.                 
  1614.                 // Attribute Authority
  1615.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1616.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_ATTRIBUTE_AUTHORITY);
  1617.                 sqlQueryObject.addSelectField("*");
  1618.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1619.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1620.                 stm = con.prepareStatement(sqlQuery);
  1621.                 stm.setLong(1, idPortaDelegata);
  1622.                 rs = stm.executeQuery();

  1624.                 while (rs.next()) {
  1625.                     
  1626.                     String nome = rs.getString("nome");
  1627.                     String attributi = rs.getString("attributi");
  1628.                     AttributeAuthority aa = new AttributeAuthority();
  1629.                     aa.setNome(nome);
  1630.                     aa.setAttributoList(DBUtils.convertToList(attributi));
  1631.                     pd.addAttributeAuthority(aa);
  1632.                 
  1633.                 }
  1634.                 rs.close();
  1635.                 stm.close();
  1636.                 
  1637.                 
  1638.                 
  1639.                 
  1640.                 // *** Aggiungo extInfo ***
  1641.                 
  1642.                 this.driver.logDebug("ExtendedInfo ...");
  1643.                 ExtendedInfoManager extInfoManager = ExtendedInfoManager.getInstance();
  1644.                 IExtendedInfo extInfoConfigurazioneDriver = extInfoManager.newInstanceExtendedInfoPortaDelegata();
  1645.                 if(extInfoConfigurazioneDriver!=null){
  1646.                     List<Object> listExtInfo = extInfoConfigurazioneDriver.getAllExtendedInfo(con, this.driver.log, pd);
  1647.                     if(listExtInfo!=null && !listExtInfo.isEmpty()){
  1648.                         for (Object object : listExtInfo) {
  1649.                             pd.addExtendedInfo(object);
  1650.                         }
  1651.                     }
  1652.                 }
  1653.                 
  1654.             } else {
  1655.                 throw new DriverConfigurazioneNotFound("[DriverConfigurazioneDB::getPortaDelegata] Nessuna PortaDelegata trovata.");
  1656.             }

  1658.             return pd;

  1660.         } catch (SQLException se) {
  1661.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] SqlException: " + se.getMessage(),se);
  1662.         } catch (DriverConfigurazioneNotFound de) {
  1663.             throw de;
  1664.         } catch (Exception se) {
  1665.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaDelegata] Exception: " + se.getMessage(),se);
  1666.         } finally {
  1667.             //Chiudo statement and resultset
  1668.             JDBCUtilities.closeResources(rs, stm);
  1669.             JDBCUtilities.closeResources(rs1, stm1);
  1670.             this.driver.closeConnection(conParam, con);
  1671.         }
  1672.     }
  1673.     
  1674.     protected List<String> porteDelegateRateLimitingValoriUnivoci(String pName) throws DriverConfigurazioneException {
  1675.         
  1676.         Connection con = null;
  1677.         PreparedStatement stmt=null;
  1678.         ResultSet risultato=null;
  1679.         ArrayList<String> lista = new ArrayList<>();

  1681.         if (this.driver.atomica) {
  1682.             try {
  1683.                 con = this.driver.getConnectionFromDatasource("porteDelegateRateLimitingValoriUnivoci");
  1684.             } catch (Exception e) {
  1685.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::porteDelegateRateLimitingValoriUnivoci] Exception accedendo al datasource :" + e.getMessage(),e);

  1687.             }

  1689.         } else
  1690.             con = this.driver.globalConnection;

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

  1694.         try {

  1696.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1697.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_RATE_LIMITING_PROP);
  1698.             sqlQueryObject.setSelectDistinct(true);
  1699.             sqlQueryObject.addSelectField("valore");
  1700.             sqlQueryObject.addWhereCondition("nome = ?");
  1701.             sqlQueryObject.setANDLogicOperator(true);
  1702.             String queryString = sqlQueryObject.createSQLQuery();
  1703.             
  1704.             stmt = con.prepareStatement(queryString);
  1705.             stmt.setString(1, pName);
  1706.             risultato = stmt.executeQuery();
  1707.             while (risultato.next()) {
  1708.                 lista.add(risultato.getString("valore"));
  1709.             }
  1710.             risultato.close();
  1711.             stmt.close();

  1713.             
  1714.             return lista;

  1716.         } catch (Exception qe) {
  1717.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::porteDelegateRateLimitingValoriUnivoci] Errore : " + qe.getMessage(),qe);
  1718.         } finally {
  1719.             //Chiudo statement and resultset
  1720.             JDBCUtilities.closeResources(risultato, stmt);
  1721.             this.driver.closeConnection(con);
  1722.         }
  1723.     }
  1724.     
  1725.     
  1726.     protected List<String> nomiProprietaPD(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoServiziProtocollo) throws DriverConfigurazioneException {
  1727.         String queryString;

  1729.         Connection con = null;
  1730.         PreparedStatement stmt=null;
  1731.         ResultSet risultato=null;
  1732.         ArrayList<String> lista = new ArrayList<>();
  1733.         String aliasSoggettiFruitori = "soggettoFruitore";

  1735.         if (this.driver.atomica) {
  1736.             try {
  1737.                 con = this.driver.getConnectionFromDatasource("nomiProprietaPD");
  1738.             } catch (Exception e) {
  1739.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::nomiProprietaPD] Exception accedendo al datasource :" + e.getMessage(),e);

  1741.             }

  1743.         } else
  1744.             con = this.driver.globalConnection;

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

  1748.         try {

  1750.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1751.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_PROP);
  1752.             sqlQueryObject.setSelectDistinct(true);
  1753.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE_PROP +".nome");
  1754.             sqlQueryObject.addOrderBy(CostantiDB.PORTE_DELEGATE_PROP +".nome"); 
  1755.             sqlQueryObject.setSortType(true);
  1756.             sqlQueryObject.setANDLogicOperator(true);
  1757.             
  1758.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome)) || (tipoServiziProtocollo != null && tipoServiziProtocollo.size() > 0)) {
  1759.                 sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  1760.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  1761.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  1762.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1763.                 
  1764.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_PROP+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  1765.                 sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  1766.                 sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_fruizione="+CostantiDB.SERVIZI_FRUITORI+".id");
  1767.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_servizio="+CostantiDB.SERVIZI+".id");
  1768.                 
  1769.             }
  1770.             
  1771.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome))) {
  1772.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI, aliasSoggettiFruitori);
  1773.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_soggetto="+aliasSoggettiFruitori+".id");
  1774.                 
  1775.                 sqlQueryObject.addWhereCondition(aliasSoggettiFruitori+".tipo_soggetto=?");
  1776.                 sqlQueryObject.addWhereCondition(aliasSoggettiFruitori+".nome_soggetto=?");
  1777.                 
  1778.             }
  1779.             
  1780.             if((tipoServiziProtocollo != null && tipoServiziProtocollo.size() > 0)) {
  1781.                 String [] tipiServiziProtocolloS = tipoServiziProtocollo.toArray(new String[tipoServiziProtocollo.size()]); 
  1782.                 sqlQueryObject.addWhereINCondition(CostantiDB.SERVIZI+".tipo_servizio", true, tipiServiziProtocolloS);
  1783.             }
  1784.             
  1785.             
  1786.             queryString = sqlQueryObject.createSQLQuery();
  1787.             stmt = con.prepareStatement(queryString);
  1788.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome))) {
  1789.                 stmt.setString(1, filterSoggettoTipo);
  1790.                 stmt.setString(2, filterSoggettoNome);
  1791.             }
  1792.             
  1793.             risultato = stmt.executeQuery();
  1794.             while (risultato.next()) {
  1795.                 lista.add(risultato.getString("nome"));
  1796.             }

  1798.             return lista;
  1799.         } catch (Exception qe) {
  1800.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::nomiProprietaPD] Errore : " + qe.getMessage(),qe);
  1801.         } finally {
  1802.             //Chiudo statement and resultset
  1803.             JDBCUtilities.closeResources(risultato, stmt);
  1804.             this.driver.closeConnection(con);
  1805.         }
  1806.     }
  1807.     
  1808.     protected List<PortaDelegata> porteDelegateWithSoggettoErogatoreList(long idSoggettoErogatore) throws DriverConfigurazioneException {
  1809.         String nomeMetodo = "porteDelegateWithSoggettoErogatoreList";
  1810.         String queryString;

  1812.         Connection con = null;
  1813.         PreparedStatement stmt=null;
  1814.         ResultSet risultato=null;
  1815.         ArrayList<PortaDelegata> lista = new ArrayList<>();

  1817.         if (this.driver.atomica) {
  1818.             try {
  1819.                 con = this.driver.getConnectionFromDatasource("porteDelegateWithSoggettoErogatoreList");
  1820.             } catch (Exception e) {
  1821.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1823.             }

  1825.         } else
  1826.             con = this.driver.globalConnection;

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

  1830.         try {

  1832.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1833.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  1834.             sqlQueryObject.addSelectField("*");
  1835.             sqlQueryObject.addWhereCondition("id_soggetto_erogatore = ?");
  1836.             queryString = sqlQueryObject.createSQLQuery();
  1837.             stmt = con.prepareStatement(queryString);
  1838.             stmt.setLong(1, idSoggettoErogatore);
  1839.             risultato = stmt.executeQuery();

  1841.             PortaDelegata pd;
  1842.             while (risultato.next()) {
  1843.                 pd = getPortaDelegata(risultato.getLong("id"),con);
  1844.                 lista.add(pd);
  1845.             }

  1847.             return lista;

  1849.         } catch (Exception qe) {
  1850.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1851.         } finally {

  1853.             //Chiudo statement and resultset
  1854.             JDBCUtilities.closeResources(risultato, stmt);

  1856.             this.driver.closeConnection(con);
  1857.         }
  1858.     }

  1860.     protected List<PortaDelegata> porteDelegateWithTipoNomeErogatoreList(String tipoSoggettoErogatore, String nomeSoggettoErogatore) throws DriverConfigurazioneException {
  1861.         String nomeMetodo = "porteDelegateWithTipoNomeErogatoreList";
  1862.         String queryString;

  1864.         Connection con = null;
  1865.         PreparedStatement stmt=null;
  1866.         ResultSet risultato=null;
  1867.         ArrayList<PortaDelegata> lista = new ArrayList<>();

  1869.         if (this.driver.atomica) {
  1870.             try {
  1871.                 con = this.driver.getConnectionFromDatasource("porteDelegateWithTipoNomeErogatoreList");
  1872.             } catch (Exception e) {
  1873.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1875.             }

  1877.         } else
  1878.             con = this.driver.globalConnection;

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

  1882.         try {

  1884.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1885.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  1886.             sqlQueryObject.addSelectField("*");
  1887.             sqlQueryObject.addWhereCondition("tipo_soggetto_erogatore = ?");
  1888.             sqlQueryObject.addWhereCondition("nome_soggetto_erogatore = ?");
  1889.             sqlQueryObject.setANDLogicOperator(true);
  1890.             queryString = sqlQueryObject.createSQLQuery();
  1891.             stmt = con.prepareStatement(queryString);
  1892.             stmt.setString(1, tipoSoggettoErogatore);
  1893.             stmt.setString(2, nomeSoggettoErogatore);
  1894.             risultato = stmt.executeQuery();

  1896.             PortaDelegata pd;
  1897.             while (risultato.next()) {
  1898.                 pd = getPortaDelegata(risultato.getLong("id"),con);
  1899.                 lista.add(pd);
  1900.             }

  1902.             return lista;

  1904.         } catch (Exception qe) {
  1905.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1906.         } finally {

  1908.             //Chiudo statement and resultset
  1909.             JDBCUtilities.closeResources(risultato, stmt);

  1911.             this.driver.closeConnection(con);
  1912.         }
  1913.     }
  1914.     
  1915.     protected boolean existsPortaDelegata(IDPortaDelegata idPD) throws DriverConfigurazioneException {

  1917.         try{
  1918.             return getPortaDelegata(idPD)!=null;
  1919.         }catch (DriverConfigurazioneNotFound e) {
  1920.             return false;
  1921.         }   
  1922.     }

  1924.     

  1926.     protected List<PortaDelegata> getPorteDelegateWithServizio(Long idServizio, String tiposervizio, String nomeservizio,
  1927.             Integer versioneServizio,
  1928.             Long idSoggetto, String tiposoggetto, String nomesoggetto) throws DriverConfigurazioneException {

  1930.         Connection con = null;
  1931.         PreparedStatement stm = null;
  1932.         ResultSet rs = null;
  1933.         String sqlQuery = "";
  1934.         ArrayList<PortaDelegata> lista = new ArrayList<PortaDelegata>();

  1936.         try {
  1937.             
  1938.             if (this.driver.atomica) {
  1939.                 try {
  1940.                     con = this.driver.getConnectionFromDatasource("getPorteDelegateWithServizio");
  1941.                 } catch (Exception e) {
  1942.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteDelegateWithServizio] Exception accedendo al datasource :" + e.getMessage(),e);

  1944.                 }

  1946.             } else
  1947.                 con = this.driver.globalConnection;
  1948.             
  1949.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1950.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  1951.             sqlQueryObject.addSelectField("*");
  1952.             sqlQueryObject.addWhereCondition(false, "id_servizio = ?", "tipo_servizio = ? AND nome_servizio = ? AND versione_servizio = ?");
  1953.             sqlQueryObject.addWhereCondition(false, "id_soggetto_erogatore = ?", "tipo_soggetto_erogatore = ? AND nome_soggetto_erogatore = ?");
  1954.             sqlQueryObject.setANDLogicOperator(true);
  1955.             sqlQuery = sqlQueryObject.createSQLQuery();
  1956.             stm = con.prepareStatement(sqlQuery);

  1958.             int index = 1;
  1959.             stm.setLong(index++, idServizio);
  1960.             stm.setString(index++, tiposervizio);
  1961.             stm.setString(index++, nomeservizio);
  1962.             stm.setInt(index++, versioneServizio);
  1963.             stm.setLong(index++, idSoggetto);
  1964.             stm.setString(index++, tiposoggetto);
  1965.             stm.setString(index++, nomesoggetto);

  1967.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idServizio, tiposervizio, nomeservizio, versioneServizio, idSoggetto, tiposoggetto, nomesoggetto));
  1968.             rs = stm.executeQuery();

  1970.             while (rs.next()) {
  1971.                 lista.add(this.getPortaDelegata(rs.getLong("id")));
  1972.             }

  1974.             return lista;
  1975.         } catch (Exception qe) {
  1976.             throw new DriverConfigurazioneException(qe);
  1977.         } finally {

  1979.             JDBCUtilities.closeResources(rs, stm);
  1980.             
  1981.             this.driver.closeConnection(con);

  1983.         }

  1985.     }

  1987.     protected List<PortaDelegata> getPorteDelegateWithServizio(Long idServizio) throws DriverConfigurazioneException {

  1989.         Connection con = null;
  1990.         PreparedStatement stm = null;
  1991.         ResultSet rs = null;
  1992.         String sqlQuery = "";
  1993.         ArrayList<PortaDelegata> lista = new ArrayList<PortaDelegata>();

  1995.         try {
  1996.             
  1997.             if (this.driver.atomica) {
  1998.                 try {
  1999.                     con = this.driver.getConnectionFromDatasource("getPorteDelegateWithServizio");
  2000.                 } catch (Exception e) {
  2001.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteDelegateWithServizio] Exception accedendo al datasource :" + e.getMessage(),e);

  2003.                 }

  2005.             } else
  2006.                 con = this.driver.globalConnection;
  2007.             
  2008.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2009.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  2010.             sqlQueryObject.addSelectField("*");
  2011.             sqlQueryObject.addWhereCondition("id_servizio = ?");
  2012.             sqlQuery = sqlQueryObject.createSQLQuery();
  2013.             stm = con.prepareStatement(sqlQuery);

  2015.             stm.setLong(1, idServizio);

  2017.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idServizio));
  2018.             rs = stm.executeQuery();

  2020.             while (rs.next()) {
  2021.                 PortaDelegata pde = this.getPortaDelegata(rs.getLong("id"));
  2022.                 lista.add(pde);
  2023.             }

  2025.             return lista;
  2026.         } catch (Exception qe) {
  2027.             throw new DriverConfigurazioneException(qe);
  2028.         } finally {

  2030.             JDBCUtilities.closeResources(rs, stm);
  2031.             
  2032.             this.driver.closeConnection(con);

  2034.         }

  2036.     }
  2037.     
  2038.     protected List<IDPortaDelegata> getPortaDelegataAzione(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2039.         Connection con = null;
  2040.         PreparedStatement stm = null;
  2041.         ResultSet rs = null;
  2042.         String sqlQuery = "";

  2044.         List<IDPortaDelegata> id = new ArrayList<IDPortaDelegata>();
  2045.         try {

  2047.             if (this.driver.atomica) {
  2048.                 try {
  2049.                     con = this.driver.getConnectionFromDatasource("getPortaDelegataAzione");
  2050.                 } catch (Exception e) {
  2051.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsPortaApplicativaAzione] Exception accedendo al datasource :" + e.getMessage(),e);

  2053.                 }

  2055.             } else
  2056.                 con = this.driver.globalConnection;
  2057.             
  2058.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2059.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  2060.             sqlQueryObject.addSelectField("*");
  2061.             sqlQueryObject.setANDLogicOperator(true);
  2062.             sqlQueryObject.addWhereCondition("nome_azione=?");
  2063.             sqlQuery = sqlQueryObject.createSQLQuery();
  2064.             stm = con.prepareStatement(sqlQuery);

  2066.             stm.setString(1, nome);

  2068.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, nome));
  2069.             rs = stm.executeQuery();

  2071.             while (rs.next()){
  2072.                 IDPortaDelegata idPD = new IDPortaDelegata();
  2073.                 idPD.setNome(rs.getString("nome_porta"));
  2074.                 id.add(idPD);
  2075.             }

  2077.         } catch (Exception qe) {
  2078.             throw new DriverConfigurazioneException(qe);
  2079.         } finally {

  2081.             JDBCUtilities.closeResources(rs, stm);
  2082.             
  2083.             this.driver.closeConnection(con);

  2085.         }

  2087.         if(id.size()>0){
  2088.             return id;
  2089.         }else{
  2090.             throw new DriverConfigurazioneNotFound("Porte Delegate che possiedono l'azione ["+nome+"] non esistenti");
  2091.         }

  2093.     }

  2095.     // NOTA: Metodo non sicuro!!! Possono esistere piu' azioni di port type diversi o accordi diversi !!!!!
  2096.     protected boolean existsPortaDelegataAzione(String nome) throws DriverConfigurazioneException {

  2098.         Connection con = null;
  2099.         PreparedStatement stm = null;
  2100.         ResultSet rs = null;
  2101.         String sqlQuery = "";

  2103.         try {
  2104.             
  2105.             if (this.driver.atomica) {
  2106.                 try {
  2107.                     con = this.driver.getConnectionFromDatasource("existsPortaDelegataAzione");
  2108.                 } catch (Exception e) {
  2109.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsPortaDelegataAzione] Exception accedendo al datasource :" + e.getMessage(),e);

  2111.                 }

  2113.             } else
  2114.                 con = this.driver.globalConnection;
  2115.             
  2116.             boolean esiste = false;
  2117.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2118.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  2119.             sqlQueryObject.addSelectField("*");
  2120.             sqlQueryObject.addWhereCondition("nome_azione=?");
  2121.             sqlQuery = sqlQueryObject.createSQLQuery();
  2122.             stm = con.prepareStatement(sqlQuery);

  2124.             stm.setString(1, nome);

  2126.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, nome));
  2127.             rs = stm.executeQuery();

  2129.             if (rs.next())
  2130.                 esiste = true;

  2132.             return esiste;
  2133.         } catch (Exception qe) {
  2134.             throw new DriverConfigurazioneException(qe);
  2135.         } finally {

  2137.             JDBCUtilities.closeResources(rs, stm);
  2138.             
  2139.             this.driver.closeConnection(con);

  2141.         }

  2143.     }
  2144.     
  2145.     protected List<PortaDelegata> getPorteDelegateBySoggetto(long idSoggetto) throws DriverConfigurazioneException {
  2146.         String nomeMetodo = "getPorteDelegateBySoggetto";

  2148.         Connection con = null;
  2149.         PreparedStatement stmt=null;
  2150.         ResultSet risultato=null;
  2151.         ArrayList<PortaDelegata> lista = new ArrayList<>();

  2153.         if (this.driver.atomica) {
  2154.             try {
  2155.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2156.             } catch (Exception e) {
  2157.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2159.             }

  2161.         } else
  2162.             con = this.driver.globalConnection;

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

  2166.         try {

  2168.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2169.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  2170.             sqlQueryObject.addSelectField("id");
  2171.             sqlQueryObject.addWhereCondition("id_soggetto=?");
  2172.             String queryString = sqlQueryObject.createSQLQuery();
  2173.             stmt = con.prepareStatement(queryString);
  2174.             stmt.setLong(1, idSoggetto);
  2175.             risultato = stmt.executeQuery();

  2177.             while (risultato.next()) {

  2179.                 Long id = risultato.getLong("id");
  2180.                 lista.add(this.getPortaDelegata(id));

  2182.             }

  2184.             return lista;

  2186.         } catch (Exception qe) {
  2187.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2188.         } finally {
  2189.             //Chiudo statement and resultset
  2190.             JDBCUtilities.closeResources(risultato, stmt);
  2191.             this.driver.closeConnection(con);
  2192.         }
  2193.     }
  2194.     
  2195.     protected List<IDPortaDelegata> getAllIdPorteDelegate(
  2196.             FiltroRicercaPorteDelegate filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  2198.         Connection con = null;
  2199.         PreparedStatement stm = null;
  2200.         ResultSet rs = null;
  2201.         List<String> nomiPD = null;
  2202.         
  2203.         this.driver.logDebug("getAllIdPorteDelegate...");

  2205.         try {
  2206.             this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  2207.             // prendo la connessione dal pool
  2208.             if (this.driver.atomica)
  2209.                 con = this.driver.getConnectionFromDatasource("getAllIdPorteDelegate");
  2210.             else
  2211.                 con = this.driver.globalConnection;

  2213.             String alias_SERVIZI_APPLICATIVI_autorizzati = "saauthz";
  2214.             String alias_SERVIZI_APPLICATIVI_token_autorizzati = "satokenauthz";
  2215.             String alias_SERVIZI_APPLICATIVI_traformazioni = "satrasf";
  2216.             String alias_SERVIZI_APPLICATIVI_TOKEN_traformazioni = "satokentrasf";
  2217.             
  2218.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2219.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  2220.             if(filtroRicerca!=null && (filtroRicerca.getTipoSoggetto()!=null || filtroRicerca.getNomeSoggetto()!=null) ){
  2221.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  2222.             }
  2223.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  2224.             if(filtroRicerca!=null && (filtroRicerca.getTipoSoggetto()!=null || filtroRicerca.getNomeSoggetto()!=null) ){
  2225.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  2226.             }
  2227.             if(filtroRicerca!=null){
  2228.                 if(filtroRicerca.getIdRuolo()!=null){
  2229.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_RUOLI);
  2230.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_RUOLI+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  2231.                 }
  2232.             }
  2233.             if(filtroRicerca!=null){
  2234.                 if(filtroRicerca.getIdScope()!=null){
  2235.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_SCOPE);
  2236.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_SCOPE+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  2237.                 }
  2238.             }
  2239.             if(filtroRicerca!=null){
  2240.                 if(filtroRicerca.getNomeServizioApplicativo()!=null){
  2241.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_SA);
  2242.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI, alias_SERVIZI_APPLICATIVI_autorizzati);
  2243.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_SA+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  2244.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_SA+".id_servizio_applicativo = "+alias_SERVIZI_APPLICATIVI_autorizzati+".id");
  2245.                 }
  2246.             }
  2247.             if(filtroRicerca!=null){
  2248.                 if(filtroRicerca.getNomeServizioApplicativoToken()!=null){
  2249.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  2250.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI, alias_SERVIZI_APPLICATIVI_token_autorizzati);
  2251.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TOKEN_SA+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  2252.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TOKEN_SA+".id_servizio_applicativo = "+alias_SERVIZI_APPLICATIVI_token_autorizzati+".id");
  2253.                 }
  2254.             }
  2255.             if(filtroRicerca!=null){
  2256.                 if(filtroRicerca.getIdRuoloToken()!=null){
  2257.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI);
  2258.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  2259.                 }
  2260.             }
  2261.             if(filtroRicerca!=null){
  2262.                 if(filtroRicerca.getNomeServizioApplicativoRiferitoApplicabilitaTrasformazione()!=null){
  2263.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_SA);
  2264.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI,alias_SERVIZI_APPLICATIVI_traformazioni);
  2265.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI);
  2266.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA);
  2267.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  2268.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA+".id_trasformazione = "+CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id");
  2269.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA+".id_servizio_applicativo = "+alias_SERVIZI_APPLICATIVI_traformazioni+".id");
  2270.                 }
  2271.             }
  2272.             if(filtroRicerca!=null){
  2273.                 if(filtroRicerca.getNomeServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()!=null){
  2274.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  2275.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI,alias_SERVIZI_APPLICATIVI_TOKEN_traformazioni);
  2276.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI);
  2277.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA);
  2278.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  2279.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA+".id_trasformazione = "+CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id");
  2280.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA+".id_servizio_applicativo = "+alias_SERVIZI_APPLICATIVI_traformazioni+".id");
  2281.                 }
  2282.             }
  2283.             boolean porteDelegatePerAzioni = false;
  2284.             if(filtroRicerca!=null && filtroRicerca.getNomePortaDelegante()!=null) {
  2285.                 porteDelegatePerAzioni = true;
  2286.                 if(filtroRicerca.getAzione()!=null) {
  2287.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  2288.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  2289.                 }
  2290.             }

  2292.             if(filtroRicerca!=null){
  2293.                 // Filtro By Data
  2294.                 if(filtroRicerca.getMinDate()!=null)
  2295.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".ora_registrazione > ?");
  2296.                 if(filtroRicerca.getMaxDate()!=null)
  2297.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".ora_registrazione < ?");
  2298.                 if(filtroRicerca.getTipoSoggetto()!=null)
  2299.                     sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto = ?");
  2300.                 if(filtroRicerca.getNomeSoggetto()!=null)
  2301.                     sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto = ?");
  2302.                 if(filtroRicerca.getTipoSoggettoErogatore()!=null)
  2303.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".tipo_soggetto_erogatore = ?");
  2304.                 if(filtroRicerca.getNomeSoggettoErogatore()!=null)
  2305.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_soggetto_erogatore = ?");
  2306.                 if(filtroRicerca.getTipoServizio()!=null)
  2307.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".tipo_servizio = ?");
  2308.                 if(filtroRicerca.getNomeServizio()!=null)
  2309.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_servizio = ?");
  2310.                 if(filtroRicerca.getVersioneServizio()!=null)
  2311.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".versione_servizio = ?");
  2312.                 if(!porteDelegatePerAzioni && filtroRicerca.getAzione()!=null)
  2313.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_azione = ?");
  2314.                 if(filtroRicerca.getNome()!=null)
  2315.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta = ?");
  2316.                 if(filtroRicerca.getIdRuolo()!=null)
  2317.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_RUOLI+".ruolo = ?");
  2318.                 if(filtroRicerca.getIdScope()!=null)
  2319.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_SCOPE+".scope = ?");
  2320.                 if(filtroRicerca.getNomeServizioApplicativo()!=null)
  2321.                     sqlQueryObject.addWhereCondition(alias_SERVIZI_APPLICATIVI_autorizzati+".nome = ?");        
  2322.                 if(filtroRicerca.getNomeServizioApplicativoToken()!=null)
  2323.                     sqlQueryObject.addWhereCondition(alias_SERVIZI_APPLICATIVI_token_autorizzati+".nome = ?");  
  2324.                 if(filtroRicerca.getIdRuoloToken()!=null)
  2325.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI+".ruolo = ?");
  2326.                 if(filtroRicerca.getNomeServizioApplicativoRiferitoApplicabilitaTrasformazione()!=null)
  2327.                     sqlQueryObject.addWhereCondition(alias_SERVIZI_APPLICATIVI_traformazioni+".nome = ?");  
  2328.                 if(filtroRicerca.getNomeServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()!=null)
  2329.                     sqlQueryObject.addWhereCondition(alias_SERVIZI_APPLICATIVI_TOKEN_traformazioni+".nome = ?");    
  2330.                 if(filtroRicerca.getStato()!=null)
  2331.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".stato = ?");
  2332.                 if(porteDelegatePerAzioni) {
  2333.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta_delegante_azione = ?");
  2334.                     if(filtroRicerca.getAzione()!=null)
  2335.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".azione = ?");
  2336.                 }
  2337.             }

  2339.             sqlQueryObject.setANDLogicOperator(true);
  2340.             String sqlQuery = sqlQueryObject.createSQLQuery();
  2341.             this.driver.logDebug("eseguo query : " + sqlQuery );
  2342.             stm = con.prepareStatement(sqlQuery);
  2343.             int indexStmt = 1;
  2344.             if(filtroRicerca!=null){
  2345.                 if(filtroRicerca.getMinDate()!=null){
  2346.                     this.driver.logDebug("minDate stmt.setTimestamp("+filtroRicerca.getMinDate()+")");
  2347.                     stm.setTimestamp(indexStmt, new Timestamp(filtroRicerca.getMinDate().getTime()));
  2348.                     indexStmt++;
  2349.                 }
  2350.                 if(filtroRicerca.getMaxDate()!=null){
  2351.                     this.driver.logDebug("maxDate stmt.setTimestamp("+filtroRicerca.getMaxDate()+")");
  2352.                     stm.setTimestamp(indexStmt, new Timestamp(filtroRicerca.getMaxDate().getTime()));
  2353.                     indexStmt++;
  2354.                 }   
  2355.                 if(filtroRicerca.getTipoSoggetto()!=null){
  2356.                     this.driver.logDebug("tipoSoggetto stmt.setString("+filtroRicerca.getTipoSoggetto()+")");
  2357.                     stm.setString(indexStmt, filtroRicerca.getTipoSoggetto());
  2358.                     indexStmt++;
  2359.                 }
  2360.                 if(filtroRicerca.getNomeSoggetto()!=null){
  2361.                     this.driver.logDebug("nomeSoggetto stmt.setString("+filtroRicerca.getNomeSoggetto()+")");
  2362.                     stm.setString(indexStmt, filtroRicerca.getNomeSoggetto());
  2363.                     indexStmt++;
  2364.                 }   
  2365.                 if(filtroRicerca.getTipoSoggettoErogatore()!=null){
  2366.                     this.driver.logDebug("tipoSoggettoErogatore stmt.setString("+filtroRicerca.getTipoSoggettoErogatore()+")");
  2367.                     stm.setString(indexStmt, filtroRicerca.getTipoSoggettoErogatore());
  2368.                     indexStmt++;
  2369.                 }
  2370.                 if(filtroRicerca.getNomeSoggettoErogatore()!=null){
  2371.                     this.driver.logDebug("nomeSoggettoErogatore stmt.setString("+filtroRicerca.getNomeSoggettoErogatore()+")");
  2372.                     stm.setString(indexStmt, filtroRicerca.getNomeSoggettoErogatore());
  2373.                     indexStmt++;
  2374.                 }   
  2375.                 if(filtroRicerca.getTipoServizio()!=null){
  2376.                     this.driver.logDebug("tipoServizio stmt.setString("+filtroRicerca.getTipoServizio()+")");
  2377.                     stm.setString(indexStmt, filtroRicerca.getTipoServizio());
  2378.                     indexStmt++;
  2379.                 }
  2380.                 if(filtroRicerca.getNomeServizio()!=null){
  2381.                     this.driver.logDebug("nomeServizio stmt.setString("+filtroRicerca.getNomeServizio()+")");
  2382.                     stm.setString(indexStmt, filtroRicerca.getNomeServizio());
  2383.                     indexStmt++;
  2384.                 }   
  2385.                 if(filtroRicerca.getVersioneServizio()!=null){
  2386.                     this.driver.logDebug("versioneServizio stmt.setInt("+filtroRicerca.getVersioneServizio()+")");
  2387.                     stm.setInt(indexStmt, filtroRicerca.getVersioneServizio());
  2388.                     indexStmt++;
  2389.                 }   
  2390.                 if(!porteDelegatePerAzioni && filtroRicerca.getAzione()!=null){
  2391.                     this.driver.logDebug("azione stmt.setString("+filtroRicerca.getAzione()+")");
  2392.                     stm.setString(indexStmt, filtroRicerca.getAzione());
  2393.                     indexStmt++;
  2394.                 }   
  2395.                 if(filtroRicerca.getNome()!=null){
  2396.                     this.driver.logDebug("nome stmt.setString("+filtroRicerca.getNome()+")");
  2397.                     stm.setString(indexStmt, filtroRicerca.getNome());
  2398.                     indexStmt++;
  2399.                 }
  2400.                 if(filtroRicerca.getIdRuolo()!=null){
  2401.                     this.driver.logDebug("ruolo stmt.setString("+filtroRicerca.getIdRuolo().getNome()+")");
  2402.                     stm.setString(indexStmt, filtroRicerca.getIdRuolo().getNome());
  2403.                     indexStmt++;
  2404.                 }
  2405.                 if(filtroRicerca.getIdScope()!=null){
  2406.                     this.driver.logDebug("scope stmt.setString("+filtroRicerca.getIdScope().getNome()+")");
  2407.                     stm.setString(indexStmt, filtroRicerca.getIdScope().getNome());
  2408.                     indexStmt++;
  2409.                 }
  2410.                 if(filtroRicerca.getNomeServizioApplicativo()!=null){
  2411.                     this.driver.logDebug("servizioApplicativoAuthz stmt.setString("+filtroRicerca.getNomeServizioApplicativo()+")");
  2412.                     stm.setString(indexStmt, filtroRicerca.getNomeServizioApplicativo());
  2413.                     indexStmt++;
  2414.                 }
  2415.                 if(filtroRicerca.getNomeServizioApplicativoToken()!=null){
  2416.                     this.driver.logDebug("servizioApplicativoTokenAuthz stmt.setString("+filtroRicerca.getNomeServizioApplicativoToken()+")");
  2417.                     stm.setString(indexStmt, filtroRicerca.getNomeServizioApplicativoToken());
  2418.                     indexStmt++;
  2419.                 }
  2420.                 if(filtroRicerca.getIdRuoloToken()!=null){
  2421.                     this.driver.logDebug("ruoloToken stmt.setString("+filtroRicerca.getIdRuoloToken().getNome()+")");
  2422.                     stm.setString(indexStmt, filtroRicerca.getIdRuoloToken().getNome());
  2423.                     indexStmt++;
  2424.                 }
  2425.                 if(filtroRicerca.getNomeServizioApplicativoRiferitoApplicabilitaTrasformazione()!=null){
  2426.                     this.driver.logDebug("servizioApplicativoTrasformazioni stmt.setString("+filtroRicerca.getNomeServizioApplicativoRiferitoApplicabilitaTrasformazione()+")");
  2427.                     stm.setString(indexStmt, filtroRicerca.getNomeServizioApplicativoRiferitoApplicabilitaTrasformazione());
  2428.                     indexStmt++;
  2429.                 }
  2430.                 if(filtroRicerca.getNomeServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()!=null){
  2431.                     this.driver.logDebug("servizioApplicativoTokenTrasformazioni stmt.setString("+filtroRicerca.getNomeServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()+")");
  2432.                     stm.setString(indexStmt, filtroRicerca.getNomeServizioApplicativoTokenRiferitoApplicabilitaTrasformazione());
  2433.                     indexStmt++;
  2434.                 }
  2435.                 if(filtroRicerca.getStato()!=null){
  2436.                     this.driver.logDebug("stato stmt.setString("+filtroRicerca.getStato().getValue()+")");
  2437.                     stm.setString(indexStmt, filtroRicerca.getStato().getValue());
  2438.                     indexStmt++;
  2439.                 }
  2440.                 if(porteDelegatePerAzioni) {
  2441.                     this.driver.logDebug("nomePortaDelegata stmt.setString("+filtroRicerca.getNomePortaDelegante()+")");
  2442.                     stm.setString(indexStmt, filtroRicerca.getNomePortaDelegante());
  2443.                     indexStmt++;
  2444.                     if(filtroRicerca.getAzione()!=null) {
  2445.                         this.driver.logDebug("azione stmt.setString("+filtroRicerca.getAzione()+")");
  2446.                         stm.setString(indexStmt, filtroRicerca.getAzione());
  2447.                         indexStmt++;
  2448.                     }
  2449.                 }
  2450.             }
  2451.             rs = stm.executeQuery();
  2452.             nomiPD = new ArrayList<>();
  2453.             while (rs.next()) {
  2454.                 nomiPD.add(rs.getString("nome_porta"));
  2455.             }
  2456.         }catch(Exception e){
  2457.             throw new DriverConfigurazioneException("getAllIdPorteDelegate error",e);
  2458.         } finally {

  2460.             //Chiudo statement and resultset
  2461.             JDBCUtilities.closeResources(rs, stm);

  2463.             this.driver.closeConnection(con);

  2465.         }
  2466.         
  2467.         if(nomiPD == null || nomiPD.size()<=0){
  2468.             if(filtroRicerca!=null)
  2469.                 throw new DriverConfigurazioneNotFound("PorteDelegate non trovate che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  2470.             else
  2471.                 throw new DriverConfigurazioneNotFound("PorteDelegate non trovate");
  2472.         }else{
  2473.             List<IDPortaDelegata> idsPD = new ArrayList<IDPortaDelegata>();
  2474.             for (String nomePortaDelegata : nomiPD) {
  2475.                 idsPD.add(this.getIDPortaDelegata(nomePortaDelegata));
  2476.             }
  2477.             return idsPD;
  2478.         }
  2479.         
  2480.     }
  2481.     
  2482.     protected List<PortaDelegata> getPorteDelegateByPolicyGestioneToken(String nome) throws DriverConfigurazioneException{
  2483.         String nomeMetodo = "getPorteDelegateByPolicyGestioneToken";

  2485.         Connection con = null;
  2486.         PreparedStatement stmt=null;
  2487.         ResultSet risultato=null;
  2488.         ArrayList<PortaDelegata> lista = new ArrayList<>();

  2490.         if (this.driver.atomica) {
  2491.             try {
  2492.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  2493.             } catch (Exception e) {
  2494.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2496.             }

  2498.         } else
  2499.             con = this.driver.globalConnection;

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

  2503.         try {

  2505.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2506.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  2507.             sqlQueryObject.addSelectField("id");
  2508.             sqlQueryObject.addWhereCondition("token_policy=?");
  2509.             String queryString = sqlQueryObject.createSQLQuery();
  2510.             stmt = con.prepareStatement(queryString);
  2511.             stmt.setString(1, nome);
  2512.             risultato = stmt.executeQuery();

  2514.             while (risultato.next()) {

  2516.                 Long id = risultato.getLong("id");
  2517.                 lista.add(this.getPortaDelegata(id));

  2519.             }

  2521.             return lista;

  2523.         } catch (Exception qe) {
  2524.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2525.         } finally {
  2526.             //Chiudo statement and resultset
  2527.             JDBCUtilities.closeResources(risultato, stmt);
  2528.             this.driver.closeConnection(con);
  2529.         }
  2530.     }
  2531.     
  2532.     protected MappingFruizionePortaDelegata getMappingFruizione(IDServizio idServizio, IDSoggetto idSoggetto, IDPortaDelegata idPortaDelegata) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  2533.         
  2534.         Connection con = null;
  2535.         if (this.driver.atomica) {
  2536.             try {
  2537.                 con = this.driver.getConnectionFromDatasource("getMappingFruizione");

  2539.             } catch (Exception e) {
  2540.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getMappingFruizione] Exception accedendo al datasource :" + e.getMessage(),e);

  2542.             }

  2544.         } else
  2545.             con = this.driver.globalConnection;

  2547.         try {
  2548.             
  2549.             return DBMappingUtils.getMappingFruizione(idServizio, idSoggetto, idPortaDelegata, con, this.driver.tipoDB);

  2551.         } catch (Exception se) {
  2552.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getMappingFruizione] Exception: " + se.getMessage(),se);
  2553.         } finally {
  2554.             this.driver.closeConnection(con);
  2555.         }
  2556.         
  2557.     }
  2558.     
  2559.     
  2560.     protected ProprietaOggetto getProprietaOggetto(IDPortaDelegata idPD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2561.         
  2562.         String nomeMetodo = "getProprietaOggetto";
  2563.         
  2564.         if (idPD == null || idPD.getNome()==null)
  2565.             throw new DriverConfigurazioneException("["+nomeMetodo+"] Parametro Non Valido");

  2567.         Connection con = null;
  2568.         PreparedStatement stm = null;
  2569.         ResultSet rs = null;
  2570.         String sqlQuery = "";

  2572.         if (this.driver.atomica) {
  2573.             try {
  2574.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);

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

  2579.             }

  2581.         } else
  2582.             con = this.driver.globalConnection;

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

  2586.         try {
  2587.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2588.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  2589.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE);
  2590.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE);
  2591.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA);
  2592.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA);
  2593.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  2594.             sqlQuery = sqlQueryObject.createSQLQuery();
  2595.             stm = con.prepareStatement(sqlQuery);

  2597.             stm.setString(1, idPD.getNome());

  2599.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPD.getNome()));
  2600.             rs = stm.executeQuery();

  2602.             ProprietaOggetto proprieta = null;
  2603.             if (rs.next()) {            
  2604.                 proprieta = this.utilsDriver.readProprietaOggetto(rs,false);
  2605.             }
  2606.             else{
  2607.                 throw new DriverConfigurazioneNotFound("PortaDelegata ["+idPD.getNome()+"] non esistente");
  2608.             }

  2610.             return proprieta;

  2612.         } catch (SQLException se) {

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

  2617.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Exception: " + se.getMessage(),se);
  2618.         }
  2619.         finally {

  2621.             //Chiudo statement and resultset
  2622.             JDBCUtilities.closeResources(rs, stm);
  2623.             this.driver.closeConnection(con);
  2624.         }
  2625.     }
  2626.     
  2627.     
  2628.     protected void updateProprietaOggetto(IDPortaDelegata idPD, String user) throws DriverConfigurazioneException {
  2629.         if(idPD==null || idPD.getNome()==null) {
  2630.             throw new DriverConfigurazioneException("Identificativo non fornito");
  2631.         }
  2632.         this.porteDriver.updateProprietaOggetto(idPD.getNome(), user, CostantiDB.PORTE_DELEGATE);
  2633.     }
  2634. }
Created with JaCoCo 0.8.8.202204050719