DriverConfigurazioneDB_porteApplicativeDriver.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.Collections;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;

  33. import org.apache.commons.lang.StringUtils;
  34. import org.openspcoop2.core.byok.IDriverBYOK;
  35. import org.openspcoop2.core.commons.DBUtils;
  36. import org.openspcoop2.core.commons.IExtendedInfo;
  37. import org.openspcoop2.core.config.AttributeAuthority;
  38. import org.openspcoop2.core.config.AutorizzazioneRuoli;
  39. import org.openspcoop2.core.config.AutorizzazioneScope;
  40. import org.openspcoop2.core.config.ConfigurazioneMessageHandlers;
  41. import org.openspcoop2.core.config.ConfigurazionePortaHandler;
  42. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  43. import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
  44. import org.openspcoop2.core.config.CorrelazioneApplicativaRisposta;
  45. import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
  46. import org.openspcoop2.core.config.CorsConfigurazione;
  47. import org.openspcoop2.core.config.DumpConfigurazione;
  48. import org.openspcoop2.core.config.GestioneToken;
  49. import org.openspcoop2.core.config.GestioneTokenAutenticazione;
  50. import org.openspcoop2.core.config.MessageSecurity;
  51. import org.openspcoop2.core.config.MessageSecurityFlow;
  52. import org.openspcoop2.core.config.MessageSecurityFlowParameter;
  53. import org.openspcoop2.core.config.MtomProcessor;
  54. import org.openspcoop2.core.config.MtomProcessorFlow;
  55. import org.openspcoop2.core.config.MtomProcessorFlowParameter;
  56. import org.openspcoop2.core.config.PortaApplicativa;
  57. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServiziApplicativi;
  58. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServizioApplicativo;
  59. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetti;
  60. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetto;
  61. import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneToken;
  62. import org.openspcoop2.core.config.PortaApplicativaAzione;
  63. import org.openspcoop2.core.config.PortaApplicativaBehaviour;
  64. import org.openspcoop2.core.config.PortaApplicativaServizio;
  65. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  66. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativoConnettore;
  67. import org.openspcoop2.core.config.PortaApplicativaSoggettoVirtuale;
  68. import org.openspcoop2.core.config.PortaTracciamento;
  69. import org.openspcoop2.core.config.Proprieta;
  70. import org.openspcoop2.core.config.ProprietaOggetto;
  71. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  72. import org.openspcoop2.core.config.Ruolo;
  73. import org.openspcoop2.core.config.Scope;
  74. import org.openspcoop2.core.config.Soggetto;
  75. import org.openspcoop2.core.config.TracciamentoConfigurazione;
  76. import org.openspcoop2.core.config.TracciamentoConfigurazioneFiletrace;
  77. import org.openspcoop2.core.config.Transazioni;
  78. import org.openspcoop2.core.config.Trasformazioni;
  79. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  80. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  81. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  82. import org.openspcoop2.core.config.constants.RuoloTipoMatch;
  83. import org.openspcoop2.core.config.constants.RuoloTipologia;
  84. import org.openspcoop2.core.config.constants.ScopeTipoMatch;
  85. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  86. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  87. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  88. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  89. import org.openspcoop2.core.config.driver.IDServizioUtils;
  90. import org.openspcoop2.core.constants.CostantiDB;
  91. import org.openspcoop2.core.id.IDConnettore;
  92. import org.openspcoop2.core.id.IDPortaApplicativa;
  93. import org.openspcoop2.core.id.IDServizio;
  94. import org.openspcoop2.core.id.IDServizioApplicativo;
  95. import org.openspcoop2.core.id.IDSoggetto;
  96. import org.openspcoop2.core.id.IdentificativiErogazione;
  97. import org.openspcoop2.core.mapping.DBMappingUtils;
  98. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  99. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  100. import org.openspcoop2.utils.sql.ISQLQueryObject;
  101. import org.openspcoop2.utils.sql.SQLObjectFactory;

  103. /**
  104.  * DriverConfigurazioneDB_porteApplicativeDriver
  105.  * 
  106.  * 
  107.  * @author Sandra Giangrandi (sandra@link.it)
  108.  * @author Stefano Corallo (corallo@link.it)
  109.  * @author $Author$
  110.  * @version $Rev$, $Date$
  111.  */
  112. public class DriverConfigurazioneDB_porteApplicativeDriver {

  114.     private DriverConfigurazioneDB driver = null;
  115.     private DriverConfigurazioneDB_porteDriver porteDriver = null;
  116.     private DriverConfigurazioneDBSoggetti soggettiDriver = null;
  117.     private DriverConfigurazioneDBUtils utilsDriver = null;
  118.     
  119.     protected DriverConfigurazioneDB_porteApplicativeDriver(DriverConfigurazioneDB driver) {
  120.         this.driver = driver;
  121.         this.porteDriver = new DriverConfigurazioneDB_porteDriver(driver);
  122.         this.soggettiDriver = new DriverConfigurazioneDBSoggetti(driver);
  123.         this.utilsDriver = new DriverConfigurazioneDBUtils(driver);
  124.     }
  125.     
  126.     protected IDPortaApplicativa getIDPortaApplicativa(String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  127.         
  128.         String nomeMetodo = "getIDPortaApplicativa";
  129.         
  130.         if (nome == null)
  131.             throw new DriverConfigurazioneException("["+nomeMetodo+"] Parametro Non Valido");

  133.         Connection con = null;
  134.         PreparedStatement stm = null;
  135.         ResultSet rs = null;
  136.         String sqlQuery = "";

  138.         if (this.driver.atomica) {
  139.             try {
  140.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);

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

  145.             }

  147.         } else
  148.             con = this.driver.globalConnection;

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

  152.         try {
  153.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  154.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  155.             sqlQueryObject.addSelectField("*");
  156.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  157.             sqlQuery = sqlQueryObject.createSQLQuery();
  158.             stm = con.prepareStatement(sqlQuery);

  160.             stm.setString(1, nome);

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

  165.             IDPortaApplicativa idPA = null;
  166.             if (rs.next()) {
  167.                 
  168.                 idPA = new IDPortaApplicativa();
  169.                 
  170.                 idPA.setNome(rs.getString("nome_porta"));
  171.                 
  172.                 IdentificativiErogazione idErogazione = new IdentificativiErogazione();
  173.                 
  174.                 IDSoggetto idSoggettoProprietario = null;
  175.                 try{
  176.                     long idSoggProprietario = rs.getLong("id_soggetto");
  177.                     idSoggettoProprietario = this.soggettiDriver.getIdSoggetto(idSoggProprietario,con);
  178.                 } catch (Exception se) {
  179.                     throw new Exception(se.getMessage()); // mappo NotFound in una eccezione generica. Il Soggetto proprietario deve esistere
  180.                 }
  181.                 

  183.                 IDSoggetto idSoggettoVirtuale = null;
  184.                 String tipoSoggVirt=rs.getString("tipo_soggetto_virtuale");
  185.                 String nomeSoggVirt=rs.getString("nome_soggetto_virtuale");
  186.                 if(nomeSoggVirt!=null && !nomeSoggVirt.equals("") && tipoSoggVirt!=null && !tipoSoggVirt.equals("")){
  187.                     idSoggettoVirtuale = new IDSoggetto(tipoSoggVirt, nomeSoggVirt);
  188.                 }
  189.                 idErogazione.setSoggettoVirtuale(idSoggettoVirtuale);

  191.                 String tipoServizio = rs.getString("tipo_servizio");
  192.                 String nomeServizio = rs.getString("servizio");
  193.                 Integer versioneServizio = rs.getInt("versione_servizio");

  195.                 String nomeProprietarioServizio = null;
  196.                 String tipoProprietarioServizio = null;
  197.                 if(nomeSoggVirt!=null && !nomeSoggVirt.equals("") && tipoSoggVirt!=null && !tipoSoggVirt.equals("")){
  198.                     nomeProprietarioServizio=nomeSoggVirt;
  199.                     tipoProprietarioServizio=tipoSoggVirt;
  200.                 }else{
  201.                     nomeProprietarioServizio=idSoggettoProprietario.getNome();
  202.                     tipoProprietarioServizio=idSoggettoProprietario.getTipo();
  203.                 }

  205.                 long idServizioPA=-1;
  206.                 try {
  207.                     idServizioPA = DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeProprietarioServizio, tipoProprietarioServizio, con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  208.                 } catch (Exception e) {
  209.                     // NON Abilitare il log, poiche' la tabella servizi puo' non esistere per il driver di configurazione 
  210.                     // in un database che non ' quello della controlstation ma quello pdd.
  211.                     //this.driver.log.info(e);
  212.                 }
  213.                 IDServizio idServizio = null;
  214.                 if( (idServizioPA>0) || (nomeServizio!=null && !nomeServizio.equals("") && tipoServizio!=null && !tipoServizio.equals("")) ){
  215.                     idServizio = IDServizioUtils.buildIDServizio(tipoServizio, nomeServizio, 
  216.                             new IDSoggetto(tipoProprietarioServizio,nomeProprietarioServizio), versioneServizio);
  217.                 }
  218.                 
  219.                 String azione = rs.getString("azione");
  220.                 if(azione!=null && !"".equals(azione) && idServizio!=null){
  221.                     idServizio.setAzione(azione);
  222.                 }
  223.                 idErogazione.setIdServizio(idServizio);

  225.                 
  226.                 idPA.setIdentificativiErogazione(idErogazione); 
  227.             }
  228.             else{
  229.                 throw new DriverConfigurazioneNotFound("PortaApplicativa ["+nome+"] non esistente");
  230.             }

  232.             return idPA;

  234.         } catch (SQLException se) {

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

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

  247.             //Chiudo statement and resultset
  248.             JDBCUtilities.closeResources(rs, stm);
  249.             this.driver.closeConnection(con);
  250.         }
  251.     }
  252.     
  253.     protected PortaApplicativa getPortaApplicativa(IDPortaApplicativa idPA) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {

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

  258.         String nome = idPA.getNome();

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

  271.             } catch (Exception e) {
  272.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] 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.                 idPortaApplicativa = DBUtils.getIdPortaApplicativa(nome, con, this.driver.tipoDB);
  286.             } catch (Exception se) {
  287.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] Exception: " + se.getMessage(),se);
  288.             }
  289.             if(idPortaApplicativa>0){
  290.                 trovato = true;
  291.             }
  292.             
  293.         } catch (Exception se) {
  294.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] Exception: " + se.getMessage(),se);
  295.         } finally {

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

  300.         if (trovato) {
  301.             pa=this.driver.getPortaApplicativa(idPortaApplicativa);

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

  307.         return pa;
  308.     }
  309.     
  310.     
  311.     protected List<PortaApplicativa> getPorteApplicative(IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  312.         return this.getEnginePortaApplicativa(idServizio, ricercaPuntuale, null);
  313.     }
  314.     
  315.     protected List<PortaApplicativa> getPorteApplicativeVirtuali(IDSoggetto soggettoVirtuale,IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  316.         return this.getEnginePortaApplicativa(idServizio, ricercaPuntuale, soggettoVirtuale);
  317.     }
  318.     
  319.         
  320.     private List<PortaApplicativa> getEnginePortaApplicativa(IDServizio service,boolean ricercaPuntuale, IDSoggetto soggettoVirtuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {

  322.         if (service==null)
  323.             throw new DriverConfigurazioneException("[getPortaApplicativa] Parametro idServizio Non Valido");

  325.         IDSoggetto soggettoErogatore = service.getSoggettoErogatore();
  326.         if ((soggettoErogatore == null) || (service == null))
  327.             throw new DriverConfigurazioneException("[getPortaApplicativa] Parametri Non Validi");
  328.         String servizio = service.getNome();
  329.         String tipoServizio = service.getTipo();
  330.         Integer versioneServizio = service.getVersione();
  331.         String azione = service.getAzione();
  332.         if ((servizio == null) || (tipoServizio == null))
  333.             throw new DriverConfigurazioneException("[getPortaApplicativa] Parametri (Servizio) Non Validi");

  335.         if(soggettoVirtuale!=null){
  336.             if(soggettoVirtuale.getTipo()==null || soggettoVirtuale.getNome()==null)
  337.                 throw new DriverConfigurazioneException("[getPortaApplicativa] Parametri (Soggetto Virtuale) non validi");
  338.         }

  340.         // Devi cercare una porta applicativa che appartiene al soggetto
  341.         // erogatore ( tipo+nome)
  342.         // e che possiede il tipoServizio,servizio e azione specificata
  343.         // Nota, siccome l'azione e' opzionale e puo' essere null,
  344.         // Se l'azione e' null, chiaramente la ricerca consiste nel trovare una
  345.         // PA con quel servizio (tipo+nome)
  346.         // Se l'azione non e' null, la ricerca deve prima essere effettuata
  347.         // anche con l'azione, e se questa fallisce,
  348.         // viene effettuata allora senza l'azione controllando solo il servizio.

  350.         // Nel caso la ricerca non sia puntuale, se non si trovano PA con un'azione specifica, si prova a cercarla con azione non definita. 

  352.         Connection con = null;
  353.         PreparedStatement stm = null;
  354.         ResultSet rs = null;
  355.         String sqlQuery = null;

  357.         if (this.driver.atomica) {
  358.             try {
  359.                 con = this.driver.getConnectionFromDatasource("getPortaApplicativa(idPortaApplicativa)");

  361.             } catch (Exception e) {
  362.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] Exception accedendo al datasource :" + e.getMessage(),e);

  364.             }

  366.         } else
  367.             con = this.driver.globalConnection;

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

  371.         List<Long> idPorteApplicative = new ArrayList<Long>();
  372.         try {
  373.             // Soggetto Proprietario della Porta Applicativa
  374.             long idSoggErog = 0;
  375.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  376.             sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  377.             sqlQueryObject.addSelectField("*");
  378.             sqlQueryObject.addWhereCondition("nome_soggetto=?");
  379.             sqlQueryObject.addWhereCondition("tipo_soggetto=?");
  380.             sqlQueryObject.setANDLogicOperator(true);
  381.             sqlQuery = sqlQueryObject.createSQLQuery();

  383.             stm = con.prepareStatement(sqlQuery,ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
  384.             stm.setString(1, soggettoErogatore.getNome());
  385.             stm.setString(2, soggettoErogatore.getTipo());
  386.             rs = stm.executeQuery();

  388.             this.driver.logDebug("eseguo query soggetto" + DBUtils.formatSQLString(sqlQuery, soggettoErogatore.getNome() ,soggettoErogatore.getTipo() ));

  390.             if (rs.next()) {
  391.                 idSoggErog = rs.getLong("id");
  392.                 rs.close();
  393.                 stm.close();
  394.             } else
  395.                 throw new DriverConfigurazioneNotFound("[DriverConfigurazioneDB::getPortaApplicativa] Nessuno soggetto trovato [" + soggettoErogatore.getNome() + "," + soggettoErogatore.getTipo() + "].");

  397.             // Eventuale SoggettoVirtuale
  398.             long idSoggVirtuale = 0;
  399.             if(soggettoVirtuale!=null){
  400.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  401.                 sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  402.                 sqlQueryObject.addSelectField("*");
  403.                 sqlQueryObject.addWhereCondition("nome_soggetto=?");
  404.                 sqlQueryObject.addWhereCondition("tipo_soggetto=?");
  405.                 sqlQueryObject.setANDLogicOperator(true);
  406.                 sqlQuery = sqlQueryObject.createSQLQuery();

  408.                 stm = con.prepareStatement(sqlQuery,ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
  409.                 stm.setString(1, soggettoVirtuale.getNome());
  410.                 stm.setString(2, soggettoVirtuale.getTipo());
  411.                 rs = stm.executeQuery();

  413.                 this.driver.logDebug("eseguo query soggetto virtuale" + DBUtils.formatSQLString(sqlQuery, soggettoVirtuale.getNome() ,soggettoVirtuale.getTipo() ));

  415.                 if (rs.next()) {
  416.                     idSoggVirtuale = rs.getLong("id");
  417.                 } 
  418.                 rs.close();
  419.                 stm.close();
  420.                 //else
  421.                 //  throw new DriverConfigurazioneNotFound("[DriverConfigurazioneDB::getPortaApplicativa] Nessuno soggetto virtuale trovato [" + soggettoVirtuale.getNome() + "," + soggettoVirtuale.getTipo() + "].");
  422.                 // L'ID non c'e' per forza. Nel database pdd, il soggetto virtuale non c'e'.
  423.             }


  426.             this.driver.logDebug("eseguo soggetto:" +idSoggErog);

  428.             if (azione == null || azione.trim().equals("")) {
  429.                 this.driver.logDebug("ricerca PA con azione == null, soggettoVirtuale="+soggettoVirtuale);
  430.                 if(soggettoVirtuale==null) {
  431.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  432.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  433.                     sqlQueryObject.addSelectField("*");
  434.                     sqlQueryObject.addWhereCondition("id_soggetto = ?");
  435.                     sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  436.                     sqlQueryObject.addWhereCondition("servizio = ?");
  437.                     sqlQueryObject.addWhereCondition("versione_servizio = ?");
  438.                     sqlQueryObject.addWhereCondition(false, "mode_azione IS NULL", "mode_azione<>?");
  439.                     sqlQueryObject.addWhereCondition(false, "azione IS NULL", "azione = ?", "azione = ?");
  440.                     sqlQueryObject.setANDLogicOperator(true);
  441.                     sqlQuery = sqlQueryObject.createSQLQuery();
  442.                 } else {
  443.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  444.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  445.                     sqlQueryObject.addSelectField("*");
  446.                     sqlQueryObject.addWhereCondition("id_soggetto = ?");
  447.                     sqlQueryObject.addWhereCondition(false, "id_soggetto_virtuale = ?", "tipo_soggetto_virtuale = ? AND nome_soggetto_virtuale = ?");
  448.                     sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  449.                     sqlQueryObject.addWhereCondition("servizio = ?");
  450.                     sqlQueryObject.addWhereCondition("versione_servizio = ?");
  451.                     sqlQueryObject.addWhereCondition(false, "mode_azione IS NULL", "mode_azione<>?");
  452.                     sqlQueryObject.addWhereCondition(false, "azione IS NULL", "azione = ?", "azione = ?");
  453.                     sqlQueryObject.setANDLogicOperator(true);
  454.                     sqlQuery = sqlQueryObject.createSQLQuery();
  455.                 }

  457.                 stm = con.prepareStatement(sqlQuery,ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

  459.                 if(soggettoVirtuale==null){
  460.                     int index = 1;
  461.                     stm.setLong(index++, idSoggErog);
  462.                     stm.setString(index++, tipoServizio);
  463.                     stm.setString(index++, servizio);
  464.                     stm.setInt(index++, versioneServizio);
  465.                     stm.setString(index++, PortaApplicativaAzioneIdentificazione.DELEGATED_BY.getValue());
  466.                     stm.setString(index++, "");
  467.                     stm.setString(index++, "-");
  468.                     this.driver.logDebug("eseguo query " + DBUtils.formatSQLString(sqlQuery, idSoggErog, tipoServizio, servizio,versioneServizio,"","-"));
  469.                 }else{
  470.                     int index = 1;
  471.                     stm.setLong(index++, idSoggErog);
  472.                     stm.setLong(index++, idSoggVirtuale);
  473.                     stm.setString(index++, soggettoVirtuale.getTipo());
  474.                     stm.setString(index++, soggettoVirtuale.getNome());
  475.                     stm.setString(index++, tipoServizio);
  476.                     stm.setString(index++, servizio);
  477.                     stm.setInt(index++, versioneServizio);
  478.                     stm.setString(index++, PortaApplicativaAzioneIdentificazione.DELEGATED_BY.getValue());
  479.                     stm.setString(index++, "");
  480.                     stm.setString(index++, "-");
  481.                     this.driver.logDebug("eseguo query " + DBUtils.formatSQLString(sqlQuery, idSoggErog, soggettoErogatore.getTipo(),soggettoErogatore.getNome(),
  482.                             tipoServizio, servizio,versioneServizio,"","-"));
  483.                 }



  487.             } else {
  488.                 this.driver.logDebug("ricerca PA con azione != null, soggettoVirtuale="+soggettoVirtuale);
  489.                 if(soggettoVirtuale==null) {
  490.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  491.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  492.                     sqlQueryObject.addSelectField("*");
  493.                     sqlQueryObject.addWhereCondition("id_soggetto=?");
  494.                     sqlQueryObject.addWhereCondition("tipo_servizio=?");
  495.                     sqlQueryObject.addWhereCondition("servizio=?");
  496.                     sqlQueryObject.addWhereCondition("versione_servizio = ?");
  497.                     sqlQueryObject.addWhereCondition(false, "mode_azione IS NULL", "mode_azione<>?");
  498.                     sqlQueryObject.addWhereCondition("azione=?");
  499.                     sqlQueryObject.setANDLogicOperator(true);
  500.                     sqlQuery = sqlQueryObject.createSQLQuery();
  501.                 } else {
  502.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  503.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  504.                     sqlQueryObject.addSelectField("*");
  505.                     sqlQueryObject.addWhereCondition("id_soggetto = ?");
  506.                     sqlQueryObject.addWhereCondition(false, "id_soggetto_virtuale = ?", "tipo_soggetto_virtuale = ? AND nome_soggetto_virtuale = ?");
  507.                     sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  508.                     sqlQueryObject.addWhereCondition("servizio = ?");
  509.                     sqlQueryObject.addWhereCondition("versione_servizio = ?");
  510.                     sqlQueryObject.addWhereCondition(false, "mode_azione IS NULL", "mode_azione<>?");
  511.                     sqlQueryObject.addWhereCondition("azione = ?");
  512.                     sqlQueryObject.setANDLogicOperator(true);
  513.                     sqlQuery = sqlQueryObject.createSQLQuery();
  514.                 }

  516.                 stm = con.prepareStatement(sqlQuery,ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

  518.                 if(soggettoVirtuale==null){
  519.                     int index = 1;
  520.                     stm.setLong(index++, idSoggErog);
  521.                     stm.setString(index++, tipoServizio);
  522.                     stm.setString(index++, servizio);
  523.                     stm.setInt(index++, versioneServizio);
  524.                     stm.setString(index++, PortaApplicativaAzioneIdentificazione.DELEGATED_BY.getValue());
  525.                     stm.setString(index++, azione);
  526.                     this.driver.logDebug("eseguo query " + DBUtils.formatSQLString(sqlQuery, idSoggErog, tipoServizio, servizio, versioneServizio, azione));
  527.                 }else
  528.                 {
  529.                     int index = 1;
  530.                     stm.setLong(index++, idSoggErog);
  531.                     stm.setLong(index++, idSoggVirtuale);
  532.                     stm.setString(index++, soggettoVirtuale.getTipo());
  533.                     stm.setString(index++, soggettoVirtuale.getNome());
  534.                     stm.setString(index++, tipoServizio);
  535.                     stm.setString(index++, servizio);
  536.                     stm.setInt(index++, versioneServizio);
  537.                     stm.setString(index++, PortaApplicativaAzioneIdentificazione.DELEGATED_BY.getValue());
  538.                     stm.setString(index++, azione);
  539.                     this.driver.logDebug("eseguo query " + DBUtils.formatSQLString(sqlQuery, idSoggErog, tipoServizio, servizio, versioneServizio, azione));
  540.                 }
  541.             }


  544.             rs = stm.executeQuery();

  546.             while(rs.next()){
  547.                 long idPortaApplicativa = rs.getLong("id");
  548.                 idPorteApplicative.add(idPortaApplicativa);
  549.             }
  550.             rs.close();
  551.             stm.close();
  552.                 

  554.             this.driver.logDebug("ricerca puntuale="+ricercaPuntuale);
  555.             if(!ricercaPuntuale){
  556.                 if (idPorteApplicative.size()==0 && azione != null) {
  557.                     this.driver.logDebug("ricerca PA con azione != null ma con solo il servizio, soggettoVirtuale="+soggettoVirtuale);
  558.             
  559.                     // in questo caso provo a cercaredelle porte applicative solo
  560.                     // con id_soggetto tipo_servizio e servizio
  561.                     if(soggettoVirtuale==null) {
  562.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  563.                         sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  564.                         sqlQueryObject.addSelectField("*");
  565.                         sqlQueryObject.addWhereCondition("id_soggetto = ?");
  566.                         sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  567.                         sqlQueryObject.addWhereCondition("servizio = ?");
  568.                         sqlQueryObject.addWhereCondition("versione_servizio = ?");
  569.                         sqlQueryObject.addWhereCondition(false, "mode_azione IS NULL", "mode_azione<>?");
  570.                         sqlQueryObject.addWhereCondition(false, "azione IS NULL", "azione = ?", "azione = ?");
  571.                         sqlQueryObject.setANDLogicOperator(true);
  572.                         sqlQuery = sqlQueryObject.createSQLQuery();
  573.                     } else {
  574.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  575.                         sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  576.                         sqlQueryObject.addSelectField("*");
  577.                         sqlQueryObject.addWhereCondition("id_soggetto = ?");
  578.                         sqlQueryObject.addWhereCondition(false, "id_soggetto_virtuale = ?", "tipo_soggetto_virtuale = ? AND nome_soggetto_virtuale = ?");
  579.                         sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  580.                         sqlQueryObject.addWhereCondition("servizio = ?");
  581.                         sqlQueryObject.addWhereCondition("versione_servizio = ?");
  582.                         sqlQueryObject.addWhereCondition(false, "mode_azione IS NULL", "mode_azione<>?");
  583.                         sqlQueryObject.addWhereCondition(false, "azione IS NULL", "azione = ?", "azione = ?");
  584.                         sqlQueryObject.setANDLogicOperator(true);
  585.                         sqlQuery = sqlQueryObject.createSQLQuery();
  586.                     }

  588.                     stm = con.prepareStatement(sqlQuery,ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

  590.                     int index = 1;
  591.                     if(soggettoVirtuale==null){
  592.                         stm.setLong(index++, idSoggErog);
  593.                         stm.setString(index++, tipoServizio);
  594.                         stm.setString(index++, servizio);
  595.                         stm.setInt(index++, versioneServizio);
  596.                         stm.setString(index++, PortaApplicativaAzioneIdentificazione.DELEGATED_BY.getValue());
  597.                         stm.setString(index++, "");
  598.                         stm.setString(index++, "-");
  599.                     }else{
  600.                         stm.setLong(index++, idSoggErog);
  601.                         stm.setLong(index++, idSoggVirtuale);
  602.                         stm.setString(index++, soggettoVirtuale.getTipo());
  603.                         stm.setString(index++, soggettoVirtuale.getNome());
  604.                         stm.setString(index++, tipoServizio);
  605.                         stm.setString(index++, servizio);
  606.                         stm.setInt(index++, versioneServizio);
  607.                         stm.setString(index++, PortaApplicativaAzioneIdentificazione.DELEGATED_BY.getValue());
  608.                         stm.setString(index++, "");
  609.                         stm.setString(index++, "-");
  610.                     }


  613.                     this.driver.logDebug("eseguo query " + DBUtils.formatSQLString(sqlQuery, idSoggErog, tipoServizio, servizio));

  615.                     rs = stm.executeQuery();

  617.                     while(rs.next()){
  618.                         long idPortaApplicativa = rs.getLong("id");
  619.                         idPorteApplicative.add(idPortaApplicativa);
  620.                     }
  621.                     
  622.                 }
  623.             }

  625.         } catch (SQLException se) {
  626.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] SqlException: " + se.getMessage(),se);
  627.         } catch (DriverConfigurazioneNotFound e) {
  628.             throw new DriverConfigurazioneNotFound(e);
  629.         }catch (Exception se) {
  630.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] Exception: " + se.getMessage(),se);
  631.         }finally {
  632.             //Chiudo statement and resultset
  633.             JDBCUtilities.closeResources(rs, stm);
  634.             this.driver.closeConnection(con);
  635.         }

  637.         if(idPorteApplicative.size()<=0){
  638.             throw new DriverConfigurazioneNotFound("Porte Applicative non esistenti");
  639.         }
  640.         List<PortaApplicativa> pa = new ArrayList<PortaApplicativa>();
  641.         for (Long idPA : idPorteApplicative) {
  642.             pa.add(this.getPortaApplicativa(idPA));
  643.         }

  645.         return pa;
  646.     }

  648.     protected void createPortaApplicativa(PortaApplicativa aPA) throws DriverConfigurazioneException {
  649.         if (aPA == null)
  650.             throw new DriverConfigurazioneException("Porta Applicativa non valida");
  651.         if (aPA.getNome() == null || aPA.getNome().equals(""))
  652.             throw new DriverConfigurazioneException("Nome Porta Applicativa non valido");
  653.         if (aPA.getNomeSoggettoProprietario() == null || aPA.getNomeSoggettoProprietario().equals(""))
  654.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Porta Applicativa non valido");
  655.         if (aPA.getTipoSoggettoProprietario() == null || aPA.getTipoSoggettoProprietario().equals(""))
  656.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Porta Applicativa non valido");

  658.         Connection con = null;
  659.         boolean error = false;

  661.         if (this.driver.atomica) {
  662.             try {
  663.                 con = this.driver.getConnectionFromDatasource("createPortaApplicativa");
  664.                 con.setAutoCommit(false);
  665.             } catch (Exception e) {
  666.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createPortaApplicativa] Exception accedendo al datasource :" + e.getMessage(),e);

  668.             }

  670.         } else
  671.             con = this.driver.globalConnection;

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

  675.         try {
  676.             this.driver.logDebug("CRUDPortaApplicativa type = 1");

  678.             DriverConfigurazioneDB_porteApplicativeLIB.CRUDPortaApplicativa(1, aPA, con, this.driver.getDriverWrapBYOK());

  680.             this.driver.logDebug("Creazione PortaApplicativa [" + aPA.getId() + "] completato.");

  682.         } catch (Exception qe) {
  683.             error = true;
  684.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createPortaApplicativa] Errore durante la creazione della PortaApplicativa : " + qe.getMessage(),qe);
  685.         } finally {

  687.             this.driver.closeConnection(error,con);
  688.         }
  689.     }
  690.     
  691.     protected void updatePortaApplicativa(PortaApplicativa aPA) throws DriverConfigurazioneException {
  692.         if (aPA == null)
  693.             throw new DriverConfigurazioneException("Porta Applicativa non valida");
  694.         if (aPA.getNome() == null || aPA.getNome().equals(""))
  695.             throw new DriverConfigurazioneException("Nome Porta Applicativa non valido");
  696.         if (aPA.getNomeSoggettoProprietario() == null || aPA.getNomeSoggettoProprietario().equals(""))
  697.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Porta Applicativa non valido");
  698.         if (aPA.getTipoSoggettoProprietario() == null || aPA.getTipoSoggettoProprietario().equals(""))
  699.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Porta Applicativa non valido");

  701.         Connection con = null;
  702.         boolean error = false;

  704.         if (this.driver.atomica) {
  705.             try {
  706.                 con = this.driver.getConnectionFromDatasource("updatePortaApplicativa");
  707.                 con.setAutoCommit(false);
  708.             } catch (Exception e) {
  709.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updatePortaApplicativa] Exception accedendo al datasource :" + e.getMessage(),e);

  711.             }

  713.         } else
  714.             con = this.driver.globalConnection;

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

  718.         try {
  719.             this.driver.logDebug("CRUDPortaApplicativa type = 2");

  721.             long id = DriverConfigurazioneDB_porteApplicativeLIB.CRUDPortaApplicativa(2, aPA, con, this.driver.getDriverWrapBYOK());

  723.             this.driver.logDebug("Aggiornamento PortaApplicativa [" + id + "] completato.");

  725.         } catch (Exception qe) {
  726.             error = true;
  727.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updatePortaApplicativa] Errore durante l'update della PortaApplicativa : " + qe.getMessage(),qe);
  728.         } finally {

  730.             this.driver.closeConnection(error,con);
  731.         }
  732.     }

  734.     protected void deletePortaApplicativa(PortaApplicativa aPA) throws DriverConfigurazioneException {
  735.         if (aPA == null)
  736.             throw new DriverConfigurazioneException("Porta Applicativa non valida");
  737.         if (aPA.getNome() == null || aPA.getNome().equals(""))
  738.             throw new DriverConfigurazioneException("Nome Porta Applicativa non valido");
  739.         if (aPA.getNomeSoggettoProprietario() == null || aPA.getNomeSoggettoProprietario().equals(""))
  740.             throw new DriverConfigurazioneException("Nome Soggetto Proprietario Porta Applicativa non valido");
  741.         if (aPA.getTipoSoggettoProprietario() == null || aPA.getTipoSoggettoProprietario().equals(""))
  742.             throw new DriverConfigurazioneException("Tipo Soggetto Proprietario Porta Applicativa non valido");

  744.         Connection con = null;
  745.         boolean error = false;

  747.         if (this.driver.atomica) {
  748.             try {
  749.                 con = this.driver.getConnectionFromDatasource("deletePortaApplicativa");
  750.                 con.setAutoCommit(false);
  751.             } catch (Exception e) {
  752.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deletePortaApplicativa] Exception accedendo al datasource :" + e.getMessage(),e);

  754.             }

  756.         } else
  757.             con = this.driver.globalConnection;

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

  761.         try {
  762.             this.driver.logDebug("CRUDPortaApplicativa type = 3");

  764.             long id = DriverConfigurazioneDB_porteApplicativeLIB.CRUDPortaApplicativa(3, aPA, con, this.driver.getDriverWrapBYOK());

  766.             this.driver.logDebug("Cancellazione PortaApplicativa [" + id + "] completato.");

  768.         } catch (Exception qe) {
  769.             error = true;
  770.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deletePortaApplicativa] Errore durante la cancellazione della PortaApplicativa : " + qe.getMessage(),qe);
  771.         } finally {

  773.             this.driver.closeConnection(error,con);
  774.         }
  775.     }

  777.     protected Map<IDSoggetto, PortaApplicativa> getPorteApplicativeSoggettiVirtuali(IDServizio idServizio) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {

  779.         this.driver.logDebug("metodo getPorteApplicativeSoggettiVirtuali in esecuzione...");

  781.         if (idServizio == null)
  782.             throw new DriverConfigurazioneException("[getPortaApplicativaSoggettiVirtuali] Parametro idServizio Non Valido");
  783.         if (idServizio.getSoggettoErogatore() == null)
  784.             throw new DriverConfigurazioneException("[getPortaApplicativaSoggettiVirtuali] Parametro Soggetto Erogatore Non Valido");
  785.         Map<IDSoggetto, PortaApplicativa> paConSoggetti = new HashMap<>();
  786.         IDSoggetto soggettoVirtuale = idServizio.getSoggettoErogatore();
  787.         String servizio = idServizio.getNome();
  788.         String tipoServizio = idServizio.getTipo();
  789.         Integer versioneServizio = idServizio.getVersione();
  790.         String azione = idServizio.getAzione();
  791.         if ((servizio == null) || (tipoServizio == null))
  792.             throw new DriverConfigurazioneException("[getPortaApplicativaSoggettiVirtuali] Parametri (Servizio) Non Validi");

  794.         /**
  795.          * // Devi cercare tutte le porte applicative che hanno come soggetto
  796.          * virtuale il soggettoVirtuale // con servizio,tipoServizio e azione
  797.          * come specificato nel precendente metodo.
  798.          *  // Per ogni porta applicativa che trovi devi creare un IDSoggetto
  799.          * del soggetto proprietario della PA trovata IDSoggetto sogg = new
  800.          * IDSoggetto(tipo,nome); // Riempi i dati della PA trovata come detto
  801.          * nel precedente metodo. PortaApplicativa pa = new PortaApplicativa();
  802.          * pa.setDescrizione(descrizione); ........ // aggiungi
  803.          * paConSoggetti.put(IDSoggetto,pa);
  804.          */
  805.         Connection con = null;
  806.         PreparedStatement stm = null;
  807.         ResultSet rs = null;
  808.         String sqlQuery = null;
  809.         ResultSet rs1=null;
  810.         PreparedStatement stm1 = null;
  811.         ResultSet rs2=null;
  812.         PreparedStatement stm2 = null;

  814.         if (this.driver.atomica) {
  815.             try {
  816.                 con = this.driver.getConnectionFromDatasource("getPorteApplicativeSoggettiVirtuali");

  818.             } catch (Exception e) {
  819.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeSoggettiVirtuali] Exception accedendo al datasource :" + e.getMessage(),e);

  821.             }

  823.         } else
  824.             con = this.driver.globalConnection;

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

  828.         try {
  829.             String nomeSoggVirt = soggettoVirtuale.getNome();
  830.             String tipoSoggVirt = soggettoVirtuale.getTipo();

  832.             if (nomeSoggVirt == null || nomeSoggVirt.equals("") || tipoSoggVirt == null || tipoSoggVirt.equals(""))
  833.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeSoggettiVirtuali] Parametri SoggettoVirtuale non corretti.");

  835.             //Prendo la lista dei soggetti presenti
  836.             ArrayList<Long> soggettiList = new ArrayList<>();
  837.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  838.             sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  839.             sqlQueryObject.addSelectField("id");
  840.             sqlQuery = sqlQueryObject.createSQLQuery();
  841.             stm = con.prepareStatement(sqlQuery);
  842.             rs = stm.executeQuery();
  843.             while (rs.next()) {
  844.                 soggettiList.add(rs.getLong(1));
  845.             }
  846.             rs.close();
  847.             stm.close();

  849.             //controllo le porte applicative dei soggetti che soddisfano i criteri di ricerca
  850.             for (Long idSoggetto : soggettiList) {
  851.                 //Azione non settata eseguo query con azione NULL
  852.                 if (azione == null || azione.trim().equals("")) {
  853.                     this.driver.logDebug("azione == null");
  854.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  855.                     sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  856.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  857.                     //sqlQueryObject.addSelectField("*");
  858.                     sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE+".descrizione", "descrizionePA");
  859.                     sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE+".id", "id_porta_applicativa");
  860.                     sqlQueryObject.addSelectAliasField(this.driver.tabellaSoggetti+".id", "id_proprietario");
  861.                     sqlQueryObject.addWhereCondition(this.driver.tabellaSoggetti+".id = "+CostantiDB.PORTE_APPLICATIVE+".id_soggetto");
  862.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_soggetto_virtuale = ?");
  863.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_soggetto_virtuale = ?");
  864.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_servizio = ?");
  865.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".servizio = ?");
  866.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".versione_servizio = ?");
  867.                     sqlQueryObject.addWhereCondition(false, CostantiDB.PORTE_APPLICATIVE+".azione IS NULL", CostantiDB.PORTE_APPLICATIVE+".azione = ?", CostantiDB.PORTE_APPLICATIVE+".azione = ?");
  868.                     sqlQueryObject.addWhereCondition(this.driver.tabellaSoggetti+".id = ?");
  869.                     sqlQueryObject.setANDLogicOperator(true);
  870.                     sqlQuery = sqlQueryObject.createSQLQuery();

  872.                     stm = con.prepareStatement(sqlQuery, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

  874.                     int index = 1;
  875.                     stm.setString(index++, nomeSoggVirt);
  876.                     stm.setString(index++, tipoSoggVirt);
  877.                     stm.setString(index++, tipoServizio);
  878.                     stm.setString(index++, servizio);
  879.                     stm.setInt(index++, versioneServizio);
  880.                     stm.setString(index++, "");
  881.                     stm.setString(index++, "-");
  882.                     stm.setLong(index++, idSoggetto);

  884.                     this.driver.logDebug("eseguo query " + DBUtils.formatSQLString(sqlQuery, nomeSoggVirt, tipoSoggVirt, tipoServizio, servizio));
  885.                 } else {
  886.                     //cerco porta applicativa con soggetto virtuale x con servizio y con azione z
  887.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  888.                     sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  889.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  890.                     //sqlQueryObject.addSelectField("*");
  891.                     sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE+".descrizione", "descrizionePA");
  892.                     sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE+".id", "id_porta_applicativa");
  893.                     sqlQueryObject.addSelectAliasField(this.driver.tabellaSoggetti+".id", "id_proprietario");
  894.                     sqlQueryObject.addWhereCondition(this.driver.tabellaSoggetti+".id = "+CostantiDB.PORTE_APPLICATIVE+".id_soggetto");
  895.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_soggetto_virtuale = ?");
  896.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_soggetto_virtuale = ?");
  897.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_servizio = ?");
  898.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".servizio = ?");
  899.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".versione_servizio = ?");
  900.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".azione = ?");
  901.                     sqlQueryObject.addWhereCondition(this.driver.tabellaSoggetti+".id = ?");
  902.                     sqlQueryObject.setANDLogicOperator(true);
  903.                     sqlQuery = sqlQueryObject.createSQLQuery();

  905.                     stm = con.prepareStatement(sqlQuery, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
  906.                     
  907.                     int index = 1;
  908.                     stm.setString(index++, nomeSoggVirt);
  909.                     stm.setString(index++, tipoSoggVirt);
  910.                     stm.setString(index++, tipoServizio);
  911.                     stm.setString(index++, servizio);
  912.                     stm.setInt(index++, versioneServizio);
  913.                     stm.setString(index++, azione);
  914.                     stm.setLong(index++, idSoggetto);

  916.                     this.driver.logDebug("eseguo query " + DBUtils.formatSQLString(sqlQuery, nomeSoggVirt, tipoSoggVirt, tipoServizio, servizio, versioneServizio, azione));
  917.                 }

  919.                 rs = stm.executeQuery();

  921.                 boolean trovato = rs.next();

  923.                 if (!trovato && azione != null) {

  925.                     this.driver.logDebug("Cerco PA generica (Azione non definita)");

  927.                     rs.close();
  928.                     stm.close();
  929.                     // in questo caso provo a cercare delle porte applicative solo
  930.                     // con id_soggetto tipo_servizio e servizio
  931.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  932.                     sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  933.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  934.                     //sqlQueryObject.addSelectField("*");
  935.                     sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE+".descrizione", "descrizionePA");
  936.                     sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE+".id", "id_porta_applicativa");
  937.                     sqlQueryObject.addSelectAliasField(this.driver.tabellaSoggetti+".id", "id_proprietario");
  938.                     sqlQueryObject.addWhereCondition(this.driver.tabellaSoggetti+".id = "+CostantiDB.PORTE_APPLICATIVE+".id_soggetto");
  939.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_soggetto_virtuale = ?");
  940.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_soggetto_virtuale = ?");
  941.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_servizio = ?");
  942.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".servizio = ?");
  943.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".versione_servizio = ?");
  944.                     sqlQueryObject.addWhereCondition(false, CostantiDB.PORTE_APPLICATIVE+".azione IS NULL", CostantiDB.PORTE_APPLICATIVE+".azione = ?", CostantiDB.PORTE_APPLICATIVE+".azione = ?");
  945.                     sqlQueryObject.addWhereCondition(this.driver.tabellaSoggetti+".id = ?");
  946.                     sqlQueryObject.setANDLogicOperator(true);
  947.                     sqlQuery = sqlQueryObject.createSQLQuery();
  948.                     this.driver.logDebug("eseguo query " + DBUtils.formatSQLString(sqlQuery, nomeSoggVirt, tipoSoggVirt, tipoServizio, servizio, versioneServizio));
  949.                     this.driver.logDebug("QUERY RAW: "+sqlQuery);

  951.                     stm = con.prepareStatement(sqlQuery, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
  952.                     
  953.                     int index = 1;
  954.                     stm.setString(index++, nomeSoggVirt);
  955.                     stm.setString(index++, tipoSoggVirt);
  956.                     stm.setString(index++, tipoServizio);
  957.                     stm.setString(index++, servizio);
  958.                     stm.setInt(index++, versioneServizio);
  959.                     stm.setString(index++, "");
  960.                     stm.setString(index++, "-");
  961.                     stm.setLong(index++, idSoggetto);



  965.                     rs = stm.executeQuery();

  967.                     trovato = rs.next();
  968.                 }
  969.                 this.driver.logDebug("Ripristino rs");
  970.                 // ripristino il cursore del resultset
  971.                 rs.beforeFirst();

  973.                 // devo iterare su tutte le pa se ho trovato delle pa
  974.                 this.driver.logDebug("Itero rs...");
  975.                 while (trovato && rs.next()) {

  977.                     this.driver.logDebug("PortaApplicativa, raccolta dati");

  979.                     long idPortaApplicativa = rs.getLong("id_porta_applicativa");
  980.                     this.driver.logDebug("PortaApplicativa, raccolta dati id["+idPortaApplicativa+"] in corso...");
  981.                     PortaApplicativa pa = this.getPortaApplicativa(idPortaApplicativa,con);
  982.                     this.driver.logDebug("PortaApplicativa, raccolta dati id["+idPortaApplicativa+"] effettuata.");


  985.                     long idSoggettoProprietario = rs.getLong("id_proprietario");
  986.                     this.driver.logDebug("PortaApplicativa, raccolta dati soggetto id["+idSoggettoProprietario+"] in corso...");

  988.                     // recupero dati del soggetto proprietario
  989.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  990.                     sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  991.                     sqlQueryObject.addSelectField("*");
  992.                     sqlQueryObject.addWhereCondition("id = ?");
  993.                     sqlQueryObject.setANDLogicOperator(true);
  994.                     sqlQuery = sqlQueryObject.createSQLQuery();
  995.                     stm1 = con.prepareStatement(sqlQuery);
  996.                     stm1.setLong(1, idSoggettoProprietario);
  997.                     rs1 = stm1.executeQuery();

  999.                     IDSoggetto soggettoProprietario = null;
  1000.                     if (rs1.next()) {
  1001.                         soggettoProprietario = new IDSoggetto(rs1.getString("tipo_soggetto"), rs1.getString("nome_soggetto"));
  1002.                     } else {
  1003.                         throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeSoggettiVirtuali] Impossibile trovare le informazioni del soggetto proprietario della PA.");
  1004.                     }
  1005.                     rs1.close();
  1006.                     stm1.close();

  1008.                     this.driver.logDebug("PortaApplicativa, raccolta dati soggetto id["+idSoggettoProprietario+"] completata.");

  1010.                     // aggiungo la pa e il soggetto all'hashtable
  1011.                     paConSoggetti.put(soggettoProprietario, pa);

  1013.                 }//chiudo while

  1015.                 rs.close();
  1016.                 stm.close();

  1018.             }//chiudo for

  1020.             if(paConSoggetti.size() == 0)
  1021.                 throw new DriverConfigurazioneNotFound("[getPorteApplicativeSoggettiVirtuali] Porte applicative di soggetti virtuali non esistenti.");

  1023.             return paConSoggetti;

  1025.         } catch (SQLException se) {
  1026.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeSoggettiVirtuali] SqlException: " + se.getMessage(),se);
  1027.         } catch (DriverConfigurazioneNotFound de) {
  1028.             throw de;
  1029.         }catch (Exception se) {
  1030.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeSoggettiVirtuali] Exception: " + se.getMessage(),se);
  1031.         }finally {
  1032.             //Chiudo statement and resultset
  1033.             JDBCUtilities.closeResources(rs2, stm2);
  1034.             JDBCUtilities.closeResources(rs1, stm1);
  1035.             JDBCUtilities.closeResources(rs, stm);
  1036.             this.driver.closeConnection(con);
  1037.         }

  1039.     }
  1040.     
  1041.     
  1042.     
  1043.     protected List<IDPortaApplicativa> porteApplicativeWithApplicativoErogatore(IDServizioApplicativo idSA) throws DriverConfigurazioneException {
  1044.         String nomeMetodo = "porteApplicativeWithApplicativoErogatore";
  1045.         
  1046.         Connection con = null;
  1047.         PreparedStatement stmt = null;
  1048.         ResultSet risultato = null;

  1050.         if (this.driver.atomica) {
  1051.             try {
  1052.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  1053.             } catch (Exception e) {
  1054.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1056.             }

  1058.         } else
  1059.             con = this.driver.globalConnection;

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

  1063.         List<IDPortaApplicativa> list = new ArrayList<IDPortaApplicativa>();
  1064.         try {
  1065.             long idSAlong = DBUtils.getIdServizioApplicativo(idSA.getNome(), idSA.getIdSoggettoProprietario().getTipo(), idSA.getIdSoggettoProprietario().getNome(), con, this.driver.tipoDB);
  1066.             
  1067.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1068.             sqlQueryObject.addSelectField("nome_porta");
  1069.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  1070.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  1071.             sqlQueryObject.setANDLogicOperator(true);
  1072.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  1073.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".id_servizio_applicativo=?");
  1074.             
  1075.             stmt = con.prepareStatement(sqlQueryObject.createSQLQuery());
  1076.             stmt.setLong(1, idSAlong);

  1078.             risultato = stmt.executeQuery();
  1079.             while (risultato.next()) {
  1080.                 String nomePorta = risultato.getString("nome_porta");
  1081.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  1082.                 idPA.setNome(nomePorta);
  1083.                 list.add(idPA);
  1084.             }
  1085.             risultato.close();
  1086.             stmt.close();


  1089.         } catch (Exception qe) {
  1090.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1091.         } finally {

  1093.             //Chiudo statement and resultset
  1094.             JDBCUtilities.closeResources(risultato, stmt);

  1096.             this.driver.closeConnection(con);
  1097.         }
  1098.         
  1099.         return list;
  1100.     }
  1101.     
  1102.     protected PortaApplicativa getPortaApplicativa(long id) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  1103.         return getPortaApplicativa(id,null);
  1104.     }
  1105.     protected PortaApplicativa getPortaApplicativa(long id,Connection conParam) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {

  1107.         if (id <= 0)
  1108.             throw new DriverConfigurazioneException("[getPortaApplicativa] L'id della Porta Applicativa deve essere > 0.");

  1110.         Connection con = null;
  1111.         PreparedStatement stm = null;
  1112.         ResultSet rs = null;
  1113.         PreparedStatement stm1 = null;
  1114.         ResultSet rs1 = null;
  1115.         PreparedStatement stm2 = null;
  1116.         ResultSet rs2 = null;
  1117.         String sqlQuery = null;

  1119.         if(conParam!=null){
  1120.             con = conParam;
  1121.         }
  1122.         else if (this.driver.atomica) {
  1123.             try {
  1124.                 con = this.driver.getConnectionFromDatasource("getPortaApplicativa(longId)");

  1126.             } catch (Exception e) {
  1127.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] Exception accedendo al datasource :" + e.getMessage(),e);

  1129.             }

  1131.         } else
  1132.             con = this.driver.globalConnection;

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

  1136.         try {
  1137.             long idPortaApplicativa = id;
  1138.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1139.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  1140.             sqlQueryObject.addFromTable(this.driver.tabellaSoggetti);
  1141.             sqlQueryObject.addSelectField("nome_porta");
  1142.             sqlQueryObject.addSelectField("tipo_soggetto");
  1143.             sqlQueryObject.addSelectField("nome_soggetto");
  1144.             sqlQueryObject.addSelectField("nome_soggetto_virtuale");
  1145.             sqlQueryObject.addSelectField("tipo_soggetto_virtuale");
  1146.             sqlQueryObject.addSelectField("servizio");
  1147.             sqlQueryObject.addSelectField("tipo_servizio");
  1148.             sqlQueryObject.addSelectField("versione_servizio");
  1149.             sqlQueryObject.addSelectField("ricevuta_asincrona_asim");
  1150.             sqlQueryObject.addSelectField("ricevuta_asincrona_sim");
  1151.             sqlQueryObject.addSelectField("integrazione");
  1152.             sqlQueryObject.addSelectField("scadenza_correlazione_appl");
  1153.             sqlQueryObject.addSelectField("allega_body");
  1154.             sqlQueryObject.addSelectField("scarta_body");
  1155.             sqlQueryObject.addSelectField("gestione_manifest");
  1156.             sqlQueryObject.addSelectField("azione");
  1157.             sqlQueryObject.addSelectField("mode_azione");
  1158.             sqlQueryObject.addSelectField("pattern_azione");
  1159.             sqlQueryObject.addSelectField("nome_porta_delegante_azione");
  1160.             sqlQueryObject.addSelectField("force_interface_based_azione");
  1161.             sqlQueryObject.addSelectField("validazione_contenuti_stato");
  1162.             sqlQueryObject.addSelectField("validazione_contenuti_tipo");
  1163.             sqlQueryObject.addSelectField("validazione_contenuti_mtom");
  1164.             sqlQueryObject.addSelectField("mtom_request_mode");
  1165.             sqlQueryObject.addSelectField("mtom_response_mode");
  1166.             sqlQueryObject.addSelectField("security");
  1167.             sqlQueryObject.addSelectField("security_mtom_req");
  1168.             sqlQueryObject.addSelectField("security_mtom_res");
  1169.             sqlQueryObject.addSelectField("security_request_mode");
  1170.             sqlQueryObject.addSelectField("security_response_mode");
  1171.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE+".id", "idPA");
  1172.             sqlQueryObject.addSelectAliasField(this.driver.tabellaSoggetti+".id", "idSoggetto");
  1173.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE+".descrizione", "descrizionePorta");
  1174.             sqlQueryObject.addSelectField("stateless");
  1175.             sqlQueryObject.addSelectField("behaviour");
  1176.             sqlQueryObject.addSelectField("autenticazione");
  1177.             sqlQueryObject.addSelectField("autenticazione_opzionale");
  1178.             sqlQueryObject.addSelectField("token_policy");
  1179.             sqlQueryObject.addSelectField("token_opzionale");
  1180.             sqlQueryObject.addSelectField("token_validazione");
  1181.             sqlQueryObject.addSelectField("token_introspection");
  1182.             sqlQueryObject.addSelectField("token_user_info");
  1183.             sqlQueryObject.addSelectField("token_forward");
  1184.             sqlQueryObject.addSelectField("token_options");
  1185.             sqlQueryObject.addSelectField("token_authn_issuer");
  1186.             sqlQueryObject.addSelectField("token_authn_client_id");
  1187.             sqlQueryObject.addSelectField("token_authn_subject");
  1188.             sqlQueryObject.addSelectField("token_authn_username");
  1189.             sqlQueryObject.addSelectField("token_authn_email");
  1190.             sqlQueryObject.addSelectField("autorizzazione");
  1191.             sqlQueryObject.addSelectField("autorizzazione_xacml");
  1192.             sqlQueryObject.addSelectField("autorizzazione_contenuto");
  1193.             sqlQueryObject.addSelectField("ruoli_match");
  1194.             sqlQueryObject.addSelectField("token_sa_stato");
  1195.             sqlQueryObject.addSelectField("token_ruoli_stato");
  1196.             sqlQueryObject.addSelectField("token_ruoli_match");
  1197.             sqlQueryObject.addSelectField("token_ruoli_tipologia");
  1198.             sqlQueryObject.addSelectField("scope_stato");
  1199.             sqlQueryObject.addSelectField("scope_match");
  1200.             sqlQueryObject.addSelectField("ricerca_porta_azione_delegata");
  1201.             sqlQueryObject.addSelectField("msg_diag_severita");
  1202.             sqlQueryObject.addSelectField("tracciamento_stato");
  1203.             sqlQueryObject.addSelectField("tracciamento_esiti");
  1204.             sqlQueryObject.addSelectField("transazioni_tempi");
  1205.             sqlQueryObject.addSelectField("transazioni_token");
  1206.             sqlQueryObject.addSelectField("stato");
  1207.             sqlQueryObject.addSelectField("cors_stato");
  1208.             sqlQueryObject.addSelectField("cors_tipo");
  1209.             sqlQueryObject.addSelectField("cors_all_allow_origins");
  1210.             sqlQueryObject.addSelectField("cors_all_allow_methods");
  1211.             sqlQueryObject.addSelectField("cors_all_allow_headers");
  1212.             sqlQueryObject.addSelectField("cors_allow_credentials");
  1213.             sqlQueryObject.addSelectField("cors_allow_max_age");
  1214.             sqlQueryObject.addSelectField("cors_allow_max_age_seconds");
  1215.             sqlQueryObject.addSelectField("cors_allow_origins");
  1216.             sqlQueryObject.addSelectField("cors_allow_headers");
  1217.             sqlQueryObject.addSelectField("cors_allow_methods");
  1218.             sqlQueryObject.addSelectField("cors_allow_expose_headers");
  1219.             sqlQueryObject.addSelectField("response_cache_stato");
  1220.             sqlQueryObject.addSelectField("response_cache_seconds");
  1221.             sqlQueryObject.addSelectField("response_cache_max_msg_size");
  1222.             sqlQueryObject.addSelectField("response_cache_hash_url");
  1223.             sqlQueryObject.addSelectField("response_cache_hash_query");
  1224.             sqlQueryObject.addSelectField("response_cache_hash_query_list");
  1225.             sqlQueryObject.addSelectField("response_cache_hash_headers");
  1226.             sqlQueryObject.addSelectField("response_cache_hash_hdr_list");
  1227.             sqlQueryObject.addSelectField("response_cache_hash_payload");
  1228.             sqlQueryObject.addSelectField("response_cache_control_nocache");
  1229.             sqlQueryObject.addSelectField("response_cache_control_maxage");
  1230.             sqlQueryObject.addSelectField("response_cache_control_nostore");
  1231.             sqlQueryObject.addSelectField("id_accordo");
  1232.             sqlQueryObject.addSelectField("id_port_type");
  1233.             sqlQueryObject.addSelectField("options");
  1234.             sqlQueryObject.addSelectField("id_sa_default");
  1235.             sqlQueryObject.addSelectField("canale");
  1236.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE,CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE,CostantiDB.PROPRIETA_OGGETTO_ALIAS_UTENTE_RICHIEDENTE);
  1237.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE,CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE,CostantiDB.PROPRIETA_OGGETTO_ALIAS_DATA_CREAZIONE);
  1238.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE,CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA,CostantiDB.PROPRIETA_OGGETTO_ALIAS_UTENTE_ULTIMA_MODIFICA);
  1239.             sqlQueryObject.addSelectAliasField(CostantiDB.PORTE_APPLICATIVE,CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA,CostantiDB.PROPRIETA_OGGETTO_ALIAS_DATA_ULTIMA_MODIFICA);
  1240.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+this.driver.tabellaSoggetti+".id");
  1241.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id = ?");
  1242.             sqlQueryObject.setANDLogicOperator(true);
  1243.             sqlQuery = sqlQueryObject.createSQLQuery();

  1245.             stm = con.prepareStatement(sqlQuery);
  1246.             stm.setLong(1, idPortaApplicativa);

  1248.             rs = stm.executeQuery();

  1250.             if (rs.next()) {

  1252.                 PortaApplicativa pa = new PortaApplicativa();
  1253.                 pa.setId(rs.getLong("idPA"));
  1254.                 long idSoggetto = rs.getLong("idSoggetto");
  1255.                 pa.setIdSoggetto(idSoggetto);
  1256.                 pa.setDescrizione(rs.getString("descrizionePorta"));
  1257.                 pa.setNome(rs.getString("nome_porta"));
  1258.                 pa.setTipoSoggettoProprietario(rs.getString("tipo_soggetto"));
  1259.                 pa.setNomeSoggettoProprietario(rs.getString("nome_soggetto"));

  1261.                 pa.setOptions(rs.getString("options"));
  1262.                 
  1263.                 pa.setIdAccordo(rs.getLong("id_accordo"));
  1264.                 pa.setIdPortType(rs.getLong("id_port_type"));

  1266.                 PortaApplicativaSoggettoVirtuale paSoggVirt = null;
  1267.                 String nomeSoggVirt=rs.getString("nome_soggetto_virtuale");
  1268.                 String tipoSoggVirt=rs.getString("tipo_soggetto_virtuale");
  1269.                 /**
  1270.                 long idSoggVirt = -1;
  1271.                 try{
  1272.                     idSoggVirt = DBUtils.getIdSoggetto(nomeSoggVirt, tipoSoggVirt, con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  1273.                 }catch (Exception e) {
  1274.                     log.error(e);
  1275.                 }
  1276.                  */
  1277.                 if(nomeSoggVirt!=null && !nomeSoggVirt.equals("") && tipoSoggVirt!=null && !tipoSoggVirt.equals("")){
  1278.                     long idSoggVirt = -1;
  1279.                     try{
  1280.                         idSoggVirt = DBUtils.getIdSoggetto(nomeSoggVirt, tipoSoggVirt, con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  1281.                     }catch (Exception e) {
  1282.                         this.driver.log.error(e.getMessage(),e);
  1283.                     }
  1284.                     paSoggVirt=new PortaApplicativaSoggettoVirtuale();
  1285.                     paSoggVirt.setId(idSoggVirt);
  1286.                     paSoggVirt.setNome(nomeSoggVirt);
  1287.                     paSoggVirt.setTipo(tipoSoggVirt);
  1288.                 }
  1289.                 pa.setSoggettoVirtuale(paSoggVirt);

  1291.                 PortaApplicativaServizio paServizio = null;
  1292.                 String nomeServizio = rs.getString("servizio");
  1293.                 String tipoServizioPA = rs.getString("tipo_servizio");
  1294.                 Integer versioneServizioPA = rs.getInt("versione_servizio");

  1296.                 String nomeProprietarioServizio = null;
  1297.                 String tipoProprietarioServizio = null;
  1298.                 if(nomeSoggVirt!=null && !nomeSoggVirt.equals("") && tipoSoggVirt!=null && !tipoSoggVirt.equals("")){
  1299.                     nomeProprietarioServizio=nomeSoggVirt;
  1300.                     tipoProprietarioServizio=tipoSoggVirt;
  1301.                 }else{
  1302.                     nomeProprietarioServizio=pa.getNomeSoggettoProprietario();
  1303.                     tipoProprietarioServizio=pa.getTipoSoggettoProprietario();
  1304.                 }

  1306.                 long idServizioPA=-1;
  1307.                 try {
  1308.                     idServizioPA = DBUtils.getIdServizio(nomeServizio, tipoServizioPA, versioneServizioPA, nomeProprietarioServizio, tipoProprietarioServizio, con, this.driver.tipoDB,this.driver.tabellaSoggetti);
  1309.                 } catch (Exception e) {
  1310.                     // NON Abilitare il log, poiche' la tabella servizi puo' non esistere per il driver di configurazione 
  1311.                     // in un database che non ' quello della controlstation ma quello pdd.
  1312.                     /**this.driver.log.info(e);*/
  1313.                 }
  1314.                 if( (idServizioPA>0) || (nomeServizio!=null && !nomeServizio.equals("") && tipoServizioPA!=null && !tipoServizioPA.equals("")) ){
  1315.                     paServizio = new PortaApplicativaServizio();
  1316.                     paServizio.setNome(nomeServizio);
  1317.                     paServizio.setTipo(tipoServizioPA);
  1318.                     paServizio.setVersione(versioneServizioPA);
  1319.                     paServizio.setId(idServizioPA);
  1320.                 }
  1321.                 pa.setServizio(paServizio);

  1323.                 
  1324.                 String azione = rs.getString("azione");
  1325.                 String modeAzione = rs.getString("mode_azione");
  1326.                 PortaApplicativaAzione paAzione=null;
  1327.                 if ((azione != null && !"-".equals(azione) && !"".equals(azione)) || (modeAzione!=null && !"".equals(modeAzione)) ) {
  1328.                     paAzione=new PortaApplicativaAzione();
  1329.                     paAzione.setNome(azione);
  1330.                     paAzione.setIdentificazione(PortaApplicativaAzioneIdentificazione.toEnumConstant(modeAzione));
  1331.                     paAzione.setPattern(rs.getString("pattern_azione"));
  1332.                     paAzione.setNomePortaDelegante(rs.getString("nome_porta_delegante_azione"));
  1333.                     paAzione.setForceInterfaceBased(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("force_interface_based_azione")));
  1334.                     pa.setAzione(paAzione);
  1335.                 }
  1336.                 
  1337.                 //ricevuta asincrona_(a)simmetrica
  1338.                 pa.setRicevutaAsincronaAsimmetrica(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("ricevuta_asincrona_asim")));
  1339.                 pa.setRicevutaAsincronaSimmetrica(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("ricevuta_asincrona_sim")));

  1341.                 //integrazione
  1342.                 pa.setIntegrazione(rs.getString("integrazione"));

  1344.                 //scadenza correlazione applicativa
  1345.                 String scadenzaCorrelazione = rs.getString("scadenza_correlazione_appl");
  1346.                 CorrelazioneApplicativa corr= null;

  1348.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1349.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_CORRELAZIONE);
  1350.                 sqlQueryObject.addSelectField("*");
  1351.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1352.                 sqlQueryObject.addOrderBy("id");
  1353.                 sqlQueryObject.setSortType(true);
  1354.                 String queryCorrApp = sqlQueryObject.createSQLQuery();
  1355.                 PreparedStatement stmCorrApp = con.prepareStatement(queryCorrApp);
  1356.                 stmCorrApp.setLong(1, idPortaApplicativa);
  1357.                 ResultSet rsCorrApp = stmCorrApp.executeQuery();
  1358.                 while (rsCorrApp.next()) {
  1359.                     if(corr==null) corr=new CorrelazioneApplicativa();
  1360.                     CorrelazioneApplicativaElemento cae = new CorrelazioneApplicativaElemento();
  1361.                     cae.setId(rsCorrApp.getLong("id"));
  1362.                     cae.setNome(rsCorrApp.getString("nome_elemento"));
  1363.                     String modeCA = rsCorrApp.getString("mode_correlazione");
  1364.                     cae.setIdentificazione(DriverConfigurazioneDBLib.getEnumCorrelazioneApplicativaRichiestaIdentificazione(modeCA));
  1365.                     /**if (modeCA.equals("urlBased") || modeCA.equals("contentBased"))*/
  1366.                     cae.setPattern(rsCorrApp.getString("pattern"));
  1367.                     cae.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumCorrelazioneApplicativaGestioneIdentificazioneFallita(rsCorrApp.getString("identificazione_fallita")));
  1368.                     corr.addElemento(cae);
  1369.                 }
  1370.                 rsCorrApp.close();
  1371.                 stmCorrApp.close();
  1372.                 if(corr!=null && scadenzaCorrelazione!=null && !scadenzaCorrelazione.equals(""))
  1373.                     corr.setScadenza(scadenzaCorrelazione);
  1374.                 pa.setCorrelazioneApplicativa(corr);
  1375.                 /**
  1376.                   if(scadenzaCorrelazione!=null && !scadenzaCorrelazione.equals("")) {
  1377.                   CorrelazioneApplicativa corr= new CorrelazioneApplicativa();
  1378.                   corr.setScadenza(scadenzaCorrelazione);
  1379.                   pd.setCorrelazioneApplicativa(corr);
  1380.                   }
  1381.                  */


  1384.                 // correlazione applicativa risposta
  1385.                 CorrelazioneApplicativaRisposta corrApplRisposta= null;

  1387.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1388.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_CORRELAZIONE_RISPOSTA);
  1389.                 sqlQueryObject.addSelectField("*");
  1390.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1391.                 sqlQueryObject.addOrderBy("id");
  1392.                 sqlQueryObject.setSortType(true);
  1393.                 queryCorrApp = sqlQueryObject.createSQLQuery();
  1394.                 stmCorrApp = con.prepareStatement(queryCorrApp);
  1395.                 stmCorrApp.setLong(1, idPortaApplicativa);
  1396.                 rsCorrApp = stmCorrApp.executeQuery();
  1397.                 while (rsCorrApp.next()) {
  1398.                     if(corrApplRisposta==null) corrApplRisposta=new CorrelazioneApplicativaRisposta();
  1399.                     CorrelazioneApplicativaRispostaElemento cae = new CorrelazioneApplicativaRispostaElemento();
  1400.                     cae.setId(rsCorrApp.getLong("id"));
  1401.                     cae.setNome(rsCorrApp.getString("nome_elemento"));
  1402.                     String modeCA = rsCorrApp.getString("mode_correlazione");
  1403.                     cae.setIdentificazione(DriverConfigurazioneDBLib.getEnumCorrelazioneApplicativaRispostaIdentificazione(modeCA));
  1404.                     /**if (modeCA.equals("urlBased") || modeCA.equals("contentBased"))*/
  1405.                     cae.setPattern(rsCorrApp.getString("pattern"));
  1406.                     cae.setIdentificazioneFallita(DriverConfigurazioneDBLib.getEnumCorrelazioneApplicativaGestioneIdentificazioneFallita(rsCorrApp.getString("identificazione_fallita")));
  1407.                     corrApplRisposta.addElemento(cae);
  1408.                 }
  1409.                 rsCorrApp.close();
  1410.                 stmCorrApp.close();
  1411.                 pa.setCorrelazioneApplicativaRisposta(corrApplRisposta);



  1415.                 // Gestione funzionalita' Attachments
  1416.                 pa.setAllegaBody(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("allega_body")));
  1417.                 pa.setScartaBody(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("scarta_body")));
  1418.                 pa.setGestioneManifest(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("gestione_manifest")));

  1420.                 // Stateless
  1421.                 pa.setStateless(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("stateless")));
  1422.                 
  1423.                 // Behaviour
  1424.                 String behaviour = rs.getString("behaviour");
  1425.                 if(behaviour!=null && !"".equals(behaviour)) {
  1426.                     pa.setBehaviour(new PortaApplicativaBehaviour());
  1427.                     pa.getBehaviour().setNome(behaviour);
  1428.                 }

  1430.                 // Autorizzazione
  1431.                 pa.setAutenticazione(rs.getString("autenticazione"));
  1432.                 pa.setAutenticazioneOpzionale(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("autenticazione_opzionale")));
  1433.                 
  1434.                 // GestioneToken
  1435.                 String tokenPolicy = rs.getString("token_policy");
  1436.                 if(tokenPolicy!=null && !"".equals(tokenPolicy)) {
  1437.                     GestioneToken gestioneToken = new GestioneToken();
  1438.                     gestioneToken.setPolicy(tokenPolicy);
  1439.                     gestioneToken.setTokenOpzionale(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("token_opzionale")));
  1440.                     gestioneToken.setValidazione(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(rs.getString("token_validazione")));
  1441.                     gestioneToken.setIntrospection(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(rs.getString("token_introspection")));
  1442.                     gestioneToken.setUserInfo(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(rs.getString("token_user_info")));
  1443.                     gestioneToken.setForward(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("token_forward")));
  1444.                     gestioneToken.setOptions(rs.getString("token_options"));
  1445.                     
  1446.                     String tokenAuthnIssuer = rs.getString("token_authn_issuer");
  1447.                     String tokenAuthnClientId = rs.getString("token_authn_client_id");
  1448.                     String tokenAuthnSubject = rs.getString("token_authn_subject");
  1449.                     String tokenAuthnUsername = rs.getString("token_authn_username");
  1450.                     String tokenAuthnEmail = rs.getString("token_authn_email");
  1451.                     if(tokenAuthnIssuer!=null ||
  1452.                             tokenAuthnClientId!=null ||
  1453.                                     tokenAuthnSubject!=null ||
  1454.                                             tokenAuthnUsername!=null ||
  1455.                                                     tokenAuthnEmail!=null) {
  1456.                         gestioneToken.setAutenticazione(new GestioneTokenAutenticazione());
  1457.                         gestioneToken.getAutenticazione().setIssuer(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnIssuer));
  1458.                         gestioneToken.getAutenticazione().setClientId(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnClientId));
  1459.                         gestioneToken.getAutenticazione().setSubject(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnSubject));
  1460.                         gestioneToken.getAutenticazione().setUsername(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnUsername));
  1461.                         gestioneToken.getAutenticazione().setEmail(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenAuthnEmail));
  1462.                     }

  1464.                     pa.setGestioneToken(gestioneToken);
  1465.                 }
  1466.                 
  1467.                 // Autorizzazione
  1468.                 pa.setAutorizzazione(rs.getString("autorizzazione"));
  1469.                 pa.setXacmlPolicy(rs.getString("autorizzazione_xacml"));
  1470.                 pa.setAutorizzazioneContenuto(rs.getString("autorizzazione_contenuto"));

  1472.                 
  1473.                 // Ricerca Porta Azione Delegata
  1474.                 if(rs.getString("ricerca_porta_azione_delegata")!=null){
  1475.                     pa.setRicercaPortaAzioneDelegata(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("ricerca_porta_azione_delegata")));
  1476.                 }
  1477.                 
  1478.                 // Tracciamento
  1479.                 String msgDiagSeverita = rs.getString("msg_diag_severita");
  1480.                 String tracciamentoStato = rs.getString("tracciamento_stato");
  1481.                 String tracciamentoEsiti = rs.getString("tracciamento_esiti");
  1482.                 String transazioniTempiElaborazione = rs.getString("transazioni_tempi");
  1483.                 String transazioniToken = rs.getString("transazioni_token");
  1484.                 TracciamentoConfigurazione tracciamentoDatabase = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, pa.getId(), 
  1485.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PA,
  1486.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB);
  1487.                 TracciamentoConfigurazione tracciamentoFiletrace = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazione(con, pa.getId(), 
  1488.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PA,
  1489.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE);
  1490.                 TracciamentoConfigurazioneFiletrace tracciamentoFiletraceDetails = DriverConfigurazioneDBTracciamentoLIB.readTracciamentoConfigurazioneFiletrace(con, pa.getId(), 
  1491.                         CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PA);
  1492.                 if( 
  1493.                         (msgDiagSeverita!=null && StringUtils.isNotEmpty(msgDiagSeverita))
  1494.                         ||
  1495.                         (tracciamentoStato!=null && StringUtils.isNotEmpty(tracciamentoStato))
  1496.                         ||
  1497.                         (tracciamentoEsiti!=null && StringUtils.isNotEmpty(tracciamentoEsiti))
  1498.                         ||
  1499.                         (transazioniTempiElaborazione!=null && StringUtils.isNotEmpty(transazioniTempiElaborazione))
  1500.                         ||
  1501.                         (transazioniToken!=null && StringUtils.isNotEmpty(transazioniToken))
  1502.                         ||
  1503.                         tracciamentoDatabase!=null
  1504.                         ||
  1505.                         tracciamentoFiletrace!=null
  1506.                         ||
  1507.                         tracciamentoFiletraceDetails!=null
  1508.                         ) {
  1509.                     PortaTracciamento tracciamento = new PortaTracciamento();
  1510.                     
  1511.                     tracciamento.setSeverita(DriverConfigurazioneDBLib.getEnumSeverita(msgDiagSeverita));
  1512.                     
  1513.                     tracciamento.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tracciamentoStato));
  1514.                     
  1515.                     tracciamento.setEsiti(tracciamentoEsiti);
  1516.                     
  1517.                     if( 
  1518.                             (transazioniTempiElaborazione!=null && StringUtils.isNotEmpty(transazioniTempiElaborazione))
  1519.                             ||
  1520.                             (transazioniToken!=null && StringUtils.isNotEmpty(transazioniToken))
  1521.                             ) {
  1522.                         tracciamento.setTransazioni(new Transazioni());
  1523.                         tracciamento.getTransazioni().setTempiElaborazione(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(transazioniTempiElaborazione));
  1524.                         tracciamento.getTransazioni().setToken(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(transazioniToken));
  1525.                     }
  1526.                     tracciamento.setDatabase(tracciamentoDatabase);
  1527.                     tracciamento.setFiletrace(tracciamentoFiletrace);
  1528.                     tracciamento.setFiletraceConfig(tracciamentoFiletraceDetails);
  1529.                     
  1530.                     pa.setTracciamento(tracciamento);
  1531.                 }
  1532.                 
  1533.                 
  1534.                 // Stato
  1535.                 if(rs.getString("stato")!=null){
  1536.                     pa.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("stato")));
  1537.                 }


  1540.                 //mtom
  1541.                 MtomProcessor mtomProcessor = null;
  1542.                 String mtomRequest = rs.getString("mtom_request_mode");
  1543.                 String mtomResponse = rs.getString("mtom_response_mode");
  1544.                 if( (mtomRequest!=null && !mtomRequest.equals(""))  ||  (mtomResponse!=null && !mtomResponse.equals("")) ){
  1545.                     mtomProcessor = new MtomProcessor();
  1546.                     if((mtomRequest!=null && !mtomRequest.equals(""))  ){
  1547.                         mtomProcessor.setRequestFlow(new MtomProcessorFlow());
  1548.                         mtomProcessor.getRequestFlow().setMode(DriverConfigurazioneDBLib.getEnumMTOMProcessorType(mtomRequest));
  1549.                     }
  1550.                     if((mtomResponse!=null && !mtomResponse.equals(""))  ){
  1551.                         mtomProcessor.setResponseFlow(new MtomProcessorFlow());
  1552.                         mtomProcessor.getResponseFlow().setMode(DriverConfigurazioneDBLib.getEnumMTOMProcessorType(mtomResponse));
  1553.                     }
  1554.                 }
  1555.                     

  1557.                 //validazione xsd
  1558.                 String validazioneContenutiStato = rs.getString("validazione_contenuti_stato");
  1559.                 String validazioneContenutiTipo = rs.getString("validazione_contenuti_tipo");
  1560.                 String validazioneContenutiMtom = rs.getString("validazione_contenuti_mtom");
  1561.                 if(  (validazioneContenutiStato!=null && !validazioneContenutiStato.equals(""))  
  1562.                         ||
  1563.                         (validazioneContenutiTipo!=null && !validazioneContenutiTipo.equals(""))    )
  1564.                 {
  1565.                     ValidazioneContenutiApplicativi val = new ValidazioneContenutiApplicativi();
  1566.                     if((validazioneContenutiStato!=null && !validazioneContenutiStato.equals(""))  )
  1567.                         val.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaConWarning(validazioneContenutiStato));
  1568.                     if((validazioneContenutiTipo!=null && !validazioneContenutiTipo.equals(""))  )
  1569.                         val.setTipo(DriverConfigurazioneDBLib.getEnumValidazioneContenutiApplicativiTipo(validazioneContenutiTipo));
  1570.                     if((validazioneContenutiMtom!=null && !validazioneContenutiMtom.equals(""))  )
  1571.                         val.setAcceptMtomMessage(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(validazioneContenutiMtom));
  1572.                     pa.setValidazioneContenutiApplicativi(val);
  1573.                 }
  1574.                 
  1575.                 
  1576.                 // messageSecurity
  1577.                 
  1578.                 String security = rs.getString("security");
  1579.                 String securityMtomReq = rs.getString("security_mtom_req");
  1580.                 String securityMtomRes = rs.getString("security_mtom_res");
  1581.                 String securityRequestMode = rs.getString("security_request_mode");
  1582.                 String securityResponseMode = rs.getString("security_response_mode");
  1583.                 MessageSecurity messageSecurity = null;
  1584.                 if(  (securityMtomReq!=null && !securityMtomReq.equals(""))  
  1585.                         ||
  1586.                         (securityRequestMode!=null && !securityRequestMode.equals(""))  
  1587.                         ||
  1588.                         (securityMtomRes!=null && !securityMtomRes.equals(""))      
  1589.                         ||
  1590.                         (securityResponseMode!=null && !securityResponseMode.equals("")) 
  1591.                         )
  1592.                 {
  1593.                     messageSecurity = new MessageSecurity();
  1594.                     if((securityMtomReq!=null && !securityMtomReq.equals(""))  ){
  1595.                         if(messageSecurity.getRequestFlow()==null) {
  1596.                             messageSecurity.setRequestFlow(new MessageSecurityFlow());  
  1597.                         }
  1598.                         messageSecurity.getRequestFlow().setApplyToMtom(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(securityMtomReq));
  1599.                     }
  1600.                     if((securityMtomRes!=null && !securityMtomRes.equals(""))  ){
  1601.                         if(messageSecurity.getResponseFlow()==null) {
  1602.                             messageSecurity.setResponseFlow(new MessageSecurityFlow()); 
  1603.                         }
  1604.                         messageSecurity.getResponseFlow().setApplyToMtom(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(securityMtomRes));
  1605.                     }
  1606.                     if((securityRequestMode!=null && !securityRequestMode.equals(""))  ){
  1607.                         if(messageSecurity.getRequestFlow()==null) {
  1608.                             messageSecurity.setRequestFlow(new MessageSecurityFlow());  
  1609.                         }
  1610.                         messageSecurity.getRequestFlow().setMode(securityRequestMode);
  1611.                     }
  1612.                     if((securityResponseMode!=null && !securityResponseMode.equals(""))  ){
  1613.                         if(messageSecurity.getResponseFlow()==null) {
  1614.                             messageSecurity.setResponseFlow(new MessageSecurityFlow()); 
  1615.                         }
  1616.                         messageSecurity.getResponseFlow().setMode(securityResponseMode);
  1617.                     }
  1618.                 }
  1619.                 
  1620.                 // RuoliMatch
  1621.                 String ruoliMatch = rs.getString("ruoli_match");
  1622.                 if(ruoliMatch!=null && !"".equals(ruoliMatch)){
  1623.                     if(pa.getRuoli()==null){
  1624.                         pa.setRuoli(new AutorizzazioneRuoli());
  1625.                     }
  1626.                     pa.getRuoli().setMatch(RuoloTipoMatch.toEnumConstant(ruoliMatch));
  1627.                 }
  1628.                 
  1629.                 // Token SA Stato
  1630.                 String tokenSaStato = rs.getString("token_sa_stato");
  1631.                 if( (tokenSaStato!=null && !"".equals(tokenSaStato)) ){
  1632.                     if(pa.getAutorizzazioneToken()==null){
  1633.                         pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  1634.                     }
  1635.                     pa.getAutorizzazioneToken().setAutorizzazioneApplicativi((DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenSaStato)));
  1636.                 }
  1637.                 
  1638.                 // Token Ruoli
  1639.                 String tokenRuoliStato = rs.getString("token_ruoli_stato");
  1640.                 String tokenRuoliMatch = rs.getString("token_ruoli_match");
  1641.                 String tokenRuoliTipologia = rs.getString("token_ruoli_tipologia");
  1642.                 if( (tokenRuoliStato!=null && !"".equals(tokenRuoliStato)) ||
  1643.                         (tokenRuoliMatch!=null && !"".equals(tokenRuoliMatch)) ||
  1644.                         (tokenRuoliTipologia!=null && !"".equals(tokenRuoliTipologia)) ){
  1645.                     if(pa.getAutorizzazioneToken()==null){
  1646.                         pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  1647.                     }
  1648.                     pa.getAutorizzazioneToken().setAutorizzazioneRuoli(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(tokenRuoliStato));
  1649.                     if((tokenRuoliMatch!=null && !"".equals(tokenRuoliMatch))) {
  1650.                         if(pa.getAutorizzazioneToken().getRuoli()==null){
  1651.                             pa.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  1652.                         }
  1653.                         pa.getAutorizzazioneToken().getRuoli().setMatch(RuoloTipoMatch.toEnumConstant(tokenRuoliMatch));
  1654.                     }
  1655.                     if((tokenRuoliTipologia!=null && !"".equals(tokenRuoliTipologia))) {
  1656.                         pa.getAutorizzazioneToken().setTipologiaRuoli(RuoloTipologia.toEnumConstant(tokenRuoliTipologia));
  1657.                     }
  1658.                 }
  1659.                 
  1660.                 // ScopeMatch
  1661.                 String scopeStato = rs.getString("scope_stato");
  1662.                 String scopeMatch = rs.getString("scope_match");
  1663.                 if( (scopeStato!=null && !"".equals(scopeStato)) || (scopeMatch!=null && !"".equals(scopeMatch)) ){
  1664.                     if(pa.getScope()==null){
  1665.                         pa.setScope(new AutorizzazioneScope());
  1666.                     }
  1667.                     pa.getScope().setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(scopeStato));
  1668.                     pa.getScope().setMatch(ScopeTipoMatch.toEnumConstant(scopeMatch));
  1669.                 }
  1670.                 
  1671.                 
  1672.                 // Gestione CORS
  1673.                 String corsStato = rs.getString("cors_stato");
  1674.                 if(corsStato!=null && !"".equals(corsStato)) {
  1675.                     pa.setGestioneCors(new CorsConfigurazione());
  1676.                     this.porteDriver.readConfigurazioneCors(pa.getGestioneCors(), rs);
  1677.                 }
  1678.                 
  1679.                 // Gestione CacheResponse
  1680.                 String responseCacheStato = rs.getString("response_cache_stato");
  1681.                 if(responseCacheStato!=null && !"".equals(responseCacheStato)) {
  1682.                     pa.setResponseCaching(new ResponseCachingConfigurazione());
  1683.                     this.porteDriver.readResponseCaching(idPortaApplicativa, false, false, pa.getResponseCaching(), rs, con);
  1684.                 }
  1685.                 
  1686.                 // Servizio Applicativo di default
  1687.                 long idSaDefault = rs.getLong("id_sa_default");
  1688.                 
  1689.                 // Canali
  1690.                 String canale = rs.getString("canale");
  1691.                 pa.setCanale(canale);
  1692.                 
  1693.                 // Proprieta Oggetto
  1694.                 pa.setProprietaOggetto(this.utilsDriver.readProprietaOggetto(rs,true));
  1695.                 
  1696.                 rs.close();
  1697.                 stm.close();

  1699.                 
  1700.                 // Servizio Applicativo di default
  1701.                 if(idSaDefault>0) {
  1702.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1703.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1704.                     sqlQueryObject.addSelectField("nome");
  1705.                     sqlQueryObject.addWhereCondition("id=?");
  1706.                     sqlQuery = sqlQueryObject.createSQLQuery();
  1707.                     stm = con.prepareStatement(sqlQuery);
  1708.                     stm.setLong(1, idSaDefault);

  1710.                     this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaApplicativa));
  1711.                     rs = stm.executeQuery();

  1713.                     // Request Flow Parameter
  1714.                     if (rs.next()) {
  1715.                         String nome = rs.getString("nome");
  1716.                         pa.setServizioApplicativoDefault(nome);
  1717.                     }
  1718.                     rs.close();
  1719.                     stm.close();
  1720.                 }
  1721.                 
  1722.                 
  1723.                 // Trasformazioni
  1724.                 Trasformazioni trasformazioni = DriverConfigurazioneDBTrasformazioniLib.readTrasformazioni(idPortaApplicativa, false, con);
  1725.                 if(trasformazioni!=null) {
  1726.                     pa.setTrasformazioni(trasformazioni);
  1727.                 }
  1728.                 
  1729.                 
  1730.                 if(paAzione!=null) {
  1731.                     // lista azioni
  1732.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1733.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AZIONI);
  1734.                     sqlQueryObject.addSelectField("*");
  1735.                     sqlQueryObject.addWhereCondition("id_porta=?");
  1736.                     sqlQuery = sqlQueryObject.createSQLQuery();
  1737.                     stm = con.prepareStatement(sqlQuery);
  1738.                     stm.setLong(1, idPortaApplicativa);

  1740.                     this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaApplicativa));
  1741.                     rs = stm.executeQuery();

  1743.                     // Request Flow Parameter
  1744.                     while (rs.next()) {
  1745.                         paAzione.addAzioneDelegata(rs.getString("azione"));
  1746.                     }
  1747.                     rs.close();
  1748.                     stm.close();
  1749.                 }
  1750.                 
  1751.                 
  1752.                 
  1753.                 // stato security
  1754.                 if (CostantiConfigurazione.ABILITATO.toString().equalsIgnoreCase(security)) {
  1755.                     pa.setStatoMessageSecurity(CostantiConfigurazione.ABILITATO.toString());
  1756.                 }else{
  1757.                     pa.setStatoMessageSecurity(CostantiConfigurazione.DISABILITATO.toString());
  1758.                 }
  1759.                 
  1760.                 // lista wss
  1761.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1762.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_REQUEST);
  1763.                 sqlQueryObject.addSelectField("*");
  1764.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1765.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1766.                 stm1 = con.prepareStatement(sqlQuery);
  1767.                 stm1.setLong(1, idPortaApplicativa);

  1769.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaApplicativa));
  1770.                 rs1 = stm1.executeQuery();

  1772.                 // Request Flow Parameter
  1773.                 MessageSecurityFlowParameter secRfp;
  1774.                 while (rs1.next()) {
  1775.                     secRfp = new MessageSecurityFlowParameter();
  1776.                     secRfp.setNome(rs1.getString("nome"));
  1777.                     
  1778.                     String plainValue = rs1.getString("valore");
  1779.                     String encValue = rs1.getString("enc_value");
  1780.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1781.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1782.                         if(driverBYOK!=null) {
  1783.                             secRfp.setValore(driverBYOK.unwrapAsString(encValue));
  1784.                         }
  1785.                         else {
  1786.                             secRfp.setValore(encValue);
  1787.                         }
  1788.                     }
  1789.                     else {
  1790.                         secRfp.setValore(plainValue);
  1791.                     }
  1792.                     
  1793.                     if(messageSecurity==null){
  1794.                         messageSecurity = new MessageSecurity();
  1795.                     }
  1796.                     if(messageSecurity.getRequestFlow()==null){
  1797.                         messageSecurity.setRequestFlow(new MessageSecurityFlow());
  1798.                     }
  1799.                     messageSecurity.getRequestFlow().addParameter(secRfp);
  1800.                 }
  1801.                 rs1.close();
  1802.                 stm1.close();

  1804.                 // Response Flow Parameter
  1805.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1806.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_MESSAGE_SECURITY_RESPONSE);
  1807.                 sqlQueryObject.addSelectField("*");
  1808.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1809.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1810.                 stm1 = con.prepareStatement(sqlQuery);
  1811.                 stm1.setLong(1, idPortaApplicativa);

  1813.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaApplicativa));
  1814.                 rs1 = stm1.executeQuery();

  1816.                 MessageSecurityFlowParameter secResfp;
  1817.                 while (rs1.next()) {
  1818.                     secResfp = new MessageSecurityFlowParameter();
  1819.                     secResfp.setNome(rs1.getString("nome"));
  1820.                     
  1821.                     String plainValue = rs1.getString("valore");
  1822.                     String encValue = rs1.getString("enc_value");
  1823.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  1824.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  1825.                         if(driverBYOK!=null) {
  1826.                             secResfp.setValore(driverBYOK.unwrapAsString(encValue));
  1827.                         }
  1828.                         else {
  1829.                             secResfp.setValore(encValue);
  1830.                         }
  1831.                     }
  1832.                     else {
  1833.                         secResfp.setValore(plainValue);
  1834.                     }
  1835.                     
  1836.                     if(messageSecurity==null){
  1837.                         messageSecurity = new MessageSecurity();
  1838.                     }
  1839.                     if(messageSecurity.getResponseFlow()==null){
  1840.                         messageSecurity.setResponseFlow(new MessageSecurityFlow());
  1841.                     }
  1842.                     messageSecurity.getResponseFlow().addParameter(secResfp);
  1843.                 }
  1844.                 rs1.close();
  1845.                 stm1.close();


  1848.                 // setto il messageSecurity
  1849.                 pa.setMessageSecurity(messageSecurity);
  1850.                 
  1851.                 
  1852.                 // mtom
  1853.                 
  1854.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1855.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_MTOM_REQUEST);
  1856.                 sqlQueryObject.addSelectField("*");
  1857.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1858.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1859.                 stm1 = con.prepareStatement(sqlQuery);
  1860.                 stm1.setLong(1, idPortaApplicativa);

  1862.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaApplicativa));
  1863.                 rs1 = stm1.executeQuery();

  1865.                 // Request Flow Parameter
  1866.                 MtomProcessorFlowParameter rfp;
  1867.                 while (rs1.next()) {
  1868.                     rfp = new MtomProcessorFlowParameter();
  1869.                     rfp.setNome(rs1.getString("nome"));
  1870.                     rfp.setPattern(rs1.getString("pattern"));
  1871.                     rfp.setContentType(rs1.getString("content_type"));
  1872.                     int required = rs1.getInt("required");
  1873.                     boolean isrequired = false;
  1874.                     if (required == CostantiDB.TRUE)
  1875.                         isrequired = true;
  1876.                     rfp.setRequired(isrequired);
  1877.                     
  1878.                     if(mtomProcessor.getRequestFlow()==null){
  1879.                         mtomProcessor.setRequestFlow(new MtomProcessorFlow());
  1880.                     }
  1881.                     mtomProcessor.getRequestFlow().addParameter(rfp);
  1882.                 }
  1883.                 rs1.close();
  1884.                 stm1.close();

  1886.                 // Response Flow Parameter
  1887.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1888.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_MTOM_RESPONSE);
  1889.                 sqlQueryObject.addSelectField("*");
  1890.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1891.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1892.                 stm1 = con.prepareStatement(sqlQuery);
  1893.                 stm1.setLong(1, idPortaApplicativa);

  1895.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPortaApplicativa));
  1896.                 rs1 = stm1.executeQuery();

  1898.                 MtomProcessorFlowParameter rsfp;
  1899.                 while (rs1.next()) {
  1900.                     rsfp = new MtomProcessorFlowParameter();
  1901.                     rsfp.setNome(rs1.getString("nome"));
  1902.                     rsfp.setPattern(rs1.getString("pattern"));
  1903.                     rsfp.setContentType(rs1.getString("content_type"));
  1904.                     int required = rs1.getInt("required");
  1905.                     boolean isrequired = false;
  1906.                     if (required == CostantiDB.TRUE)
  1907.                         isrequired = true;
  1908.                     rsfp.setRequired(isrequired);
  1909.                     
  1910.                     if(mtomProcessor.getResponseFlow()==null){
  1911.                         mtomProcessor.setResponseFlow(new MtomProcessorFlow());
  1912.                     }
  1913.                     mtomProcessor.getResponseFlow().addParameter(rsfp);
  1914.                 }
  1915.                 rs1.close();
  1916.                 stm1.close();
  1917.                 
  1918.                 // set mtom
  1919.                 pa.setMtomProcessor(mtomProcessor);
  1920.                 

  1922.                 // pa.addServizioApplicativo(servizioApplicativo); .... solo i
  1923.                 // NOMI!!!
  1924.                 // servizi applicativi
  1925.                 long idSA = 0;
  1926.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1927.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  1928.                 sqlQueryObject.addSelectField("*");
  1929.                 sqlQueryObject.addWhereCondition("id_porta=?");
  1930.                 sqlQuery = sqlQueryObject.createSQLQuery();
  1931.                 stm = con.prepareStatement(sqlQuery);
  1932.                 stm.setLong(1, idPortaApplicativa);
  1933.                 rs = stm.executeQuery();

  1935.                 // per ogni entry con id_porta == idPortaApplicativa
  1936.                 // prendo l'id del servizio associato, recupero il nome e
  1937.                 // aggiungo
  1938.                 // il servizio applicativo alla PortaDelegata da ritornare
  1939.                 while (rs.next()) {
  1940.                     long idSaPa = rs.getLong("id");
  1941.                     idSA = rs.getLong("id_servizio_applicativo");

  1943.                     String nomeConnettore = rs.getString("connettore_nome");
  1944.                     int notificaConnettore = rs.getInt("connettore_notifica");
  1945.                     String descrizioneConnettore = rs.getString("connettore_descrizione");
  1946.                     String statoConnettore = rs.getString("connettore_stato");
  1947.                     String schedulingConnettore = rs.getString("connettore_scheduling");
  1948.                     String filtriConnettore = rs.getString("connettore_filtri");
  1949.                     String codaConnettore = rs.getString("connettore_coda");
  1950.                     String prioritaConnettore = rs.getString("connettore_priorita");
  1951.                     int maxPrioritaConnettore = rs.getInt("connettore_max_priorita");
  1952.                     
  1953.                     if (idSA != 0) {
  1954.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1955.                         sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1956.                         sqlQueryObject.addSelectField("nome");
  1957.                         sqlQueryObject.addWhereCondition("id=?");
  1958.                         sqlQuery = sqlQueryObject.createSQLQuery();
  1959.                         stm1 = con.prepareStatement(sqlQuery);
  1960.                         stm1.setLong(1, idSA);

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

  1964.                         rs1 = stm1.executeQuery();

  1966.                         PortaApplicativaServizioApplicativo servizioApplicativo = null;
  1967.                         
  1968.                         if (rs1.next()) {
  1969.                             // setto solo il nome come da specifica
  1970.                             servizioApplicativo = new PortaApplicativaServizioApplicativo();
  1971.                             servizioApplicativo.setId(idSaPa);
  1972.                             servizioApplicativo.setIdServizioApplicativo(idSA); 
  1973.                             servizioApplicativo.setNome(rs1.getString("nome"));
  1974.                             
  1975.                             if(nomeConnettore!=null && !"".equals(nomeConnettore)) {
  1976.                                 servizioApplicativo.setDatiConnettore(new PortaApplicativaServizioApplicativoConnettore());
  1977.                                 servizioApplicativo.getDatiConnettore().setNome(nomeConnettore);
  1978.                                 servizioApplicativo.getDatiConnettore().setNotifica(notificaConnettore == CostantiDB.TRUE);
  1979.                                 servizioApplicativo.getDatiConnettore().setDescrizione(descrizioneConnettore);
  1980.                                 if(statoConnettore!=null) {
  1981.                                     // prende il default
  1982.                                     servizioApplicativo.getDatiConnettore().setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(statoConnettore));
  1983.                                 }
  1984.                                 if(schedulingConnettore!=null) {
  1985.                                     // prende il default
  1986.                                     servizioApplicativo.getDatiConnettore().setScheduling(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(schedulingConnettore));
  1987.                                 }
  1988.                                 servizioApplicativo.getDatiConnettore().setCoda(codaConnettore);
  1989.                                 servizioApplicativo.getDatiConnettore().setPriorita(prioritaConnettore);
  1990.                                 servizioApplicativo.getDatiConnettore().setPrioritaMax(maxPrioritaConnettore == CostantiDB.TRUE);
  1991.                                 
  1992.                                 List<String> l = DBUtils.convertToList(filtriConnettore);
  1993.                                 if(!l.isEmpty()) {
  1994.                                     servizioApplicativo.getDatiConnettore().setFiltroList(l);
  1995.                                 }
  1996.                                 
  1997.                                 servizioApplicativo.getDatiConnettore().setProprietaOggetto(this.utilsDriver.readProprietaOggetto(rs,false));
  1998.                                 
  1999.                                 Proprieta prop = null;
  2000.                                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2001.                                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA_PROPS);
  2002.                                 sqlQueryObject.addSelectField("*");
  2003.                                 sqlQueryObject.addWhereCondition("id_porta=?");
  2004.                                 sqlQuery = sqlQueryObject.createSQLQuery();
  2005.                                 stm2 = con.prepareStatement(sqlQuery);
  2006.                                 stm2.setLong(1, idSaPa);
  2007.                                 rs2=stm2.executeQuery();
  2008.                                 while (rs2.next()) {
  2009.                                     prop = new Proprieta();
  2010.                                     prop.setId(rs2.getLong("id"));
  2011.                                     prop.setNome(rs2.getString("nome"));
  2012.                                     prop.setValore(rs2.getString("valore"));
  2013.                                     servizioApplicativo.getDatiConnettore().addProprieta(prop);
  2014.                                 }
  2015.                                 rs2.close();
  2016.                                 stm2.close();
  2017.                             }
  2018.                             
  2019.                             pa.addServizioApplicativo(servizioApplicativo);
  2020.                         }
  2021.                         rs1.close();
  2022.                         stm1.close();
  2023.                         
  2024.                         
  2025.                     }
  2026.                 }
  2027.                 rs.close();
  2028.                 stm.close();
  2029.                 
  2030.                 
  2031.                 if(pa.getBehaviour()!=null) {
  2032.                     // behaviour prop
  2033.                     Proprieta prop = null;
  2034.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2035.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_BEHAVIOUR_PROPS);
  2036.                     sqlQueryObject.addSelectField("*");
  2037.                     sqlQueryObject.addWhereCondition("id_porta=?");
  2038.                     sqlQuery = sqlQueryObject.createSQLQuery();
  2039.                     stm = con.prepareStatement(sqlQuery);
  2040.                     stm.setLong(1, idPortaApplicativa);
  2041.                     rs=stm.executeQuery();
  2042.                     while (rs.next()) {
  2043.                         prop = new Proprieta();
  2044.                         prop.setId(rs.getLong("id"));
  2045.                         prop.setNome(rs.getString("nome"));
  2046.                         prop.setValore(rs.getString("valore"));
  2047.                         pa.getBehaviour().addProprieta(prop);
  2048.                     }
  2049.                     rs.close();
  2050.                     stm.close();
  2051.                 }
  2052.                 
  2053.                 
  2054.                 // autenticazione prop
  2055.                 Proprieta prop = null;
  2056.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2057.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AUTENTICAZIONE_PROP);
  2058.                 sqlQueryObject.addSelectField("*");
  2059.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2060.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2061.                 stm = con.prepareStatement(sqlQuery);
  2062.                 stm.setLong(1, idPortaApplicativa);
  2063.                 rs=stm.executeQuery();
  2064.                 while (rs.next()) {
  2065.                     prop = new Proprieta();
  2066.                     prop.setId(rs.getLong("id"));
  2067.                     prop.setNome(rs.getString("nome"));
  2068.                     
  2069.                     String plainValue = rs.getString("valore");
  2070.                     String encValue = rs.getString("enc_value");
  2071.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  2072.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  2073.                         if(driverBYOK!=null) {
  2074.                             prop.setValore(driverBYOK.unwrapAsString(encValue));
  2075.                         }
  2076.                         else {
  2077.                             prop.setValore(encValue);
  2078.                         }
  2079.                     }
  2080.                     else {
  2081.                         prop.setValore(plainValue);
  2082.                     }
  2083.                     
  2084.                     pa.addProprietaAutenticazione(prop);
  2085.                 }
  2086.                 rs.close();
  2087.                 stm.close();
  2088.                 
  2089.                 
  2090.                 
  2091.                 // autorizzazione prop
  2092.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2093.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_PROP);
  2094.                 sqlQueryObject.addSelectField("*");
  2095.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2096.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2097.                 stm = con.prepareStatement(sqlQuery);
  2098.                 stm.setLong(1, idPortaApplicativa);
  2099.                 rs=stm.executeQuery();
  2100.                 while (rs.next()) {
  2101.                     prop = new Proprieta();
  2102.                     prop.setId(rs.getLong("id"));
  2103.                     prop.setNome(rs.getString("nome"));
  2104.                     
  2105.                     String plainValue = rs.getString("valore");
  2106.                     String encValue = rs.getString("enc_value");
  2107.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  2108.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  2109.                         if(driverBYOK!=null) {
  2110.                             prop.setValore(driverBYOK.unwrapAsString(encValue));
  2111.                         }
  2112.                         else {
  2113.                             prop.setValore(encValue);
  2114.                         }
  2115.                     }
  2116.                     else {
  2117.                         prop.setValore(plainValue);
  2118.                     }
  2119.                     
  2120.                     pa.addProprietaAutorizzazione(prop);
  2121.                 }
  2122.                 rs.close();
  2123.                 stm.close();
  2124.                 
  2125.                 
  2126.                 
  2127.                 
  2128.                 // autorizzazione per contenuti prop
  2129.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2130.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AUTORIZZAZIONE_CONTENUTI_PROP);
  2131.                 sqlQueryObject.addSelectField("*");
  2132.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2133.                 sqlQueryObject.addOrderBy("id", true); // per preservare l'ordine di inserimento per l'autorizzazione per contenuti built-in visualizzata
  2134.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2135.                 stm = con.prepareStatement(sqlQuery);
  2136.                 stm.setLong(1, idPortaApplicativa);
  2137.                 rs=stm.executeQuery();
  2138.                 while (rs.next()) {
  2139.                     prop = new Proprieta();
  2140.                     prop.setId(rs.getLong("id"));
  2141.                     prop.setNome(rs.getString("nome"));
  2142.                     
  2143.                     String plainValue = rs.getString("valore");
  2144.                     String encValue = rs.getString("enc_value");
  2145.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  2146.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  2147.                         if(driverBYOK!=null) {
  2148.                             prop.setValore(driverBYOK.unwrapAsString(encValue));
  2149.                         }
  2150.                         else {
  2151.                             prop.setValore(encValue);
  2152.                         }
  2153.                     }
  2154.                     else {
  2155.                         prop.setValore(plainValue);
  2156.                     }
  2157.                     
  2158.                     pa.addProprietaAutorizzazioneContenuto(prop);
  2159.                 }
  2160.                 rs.close();
  2161.                 stm.close();
  2162.                 
  2163.                 
  2164.                 
  2165.                 
  2166.                 
  2167.                 // rate limiting prop
  2168.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2169.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_RATE_LIMITING_PROP);
  2170.                 sqlQueryObject.addSelectField("*");
  2171.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2172.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2173.                 stm = con.prepareStatement(sqlQuery);
  2174.                 stm.setLong(1, idPortaApplicativa);
  2175.                 rs=stm.executeQuery();
  2176.                 while (rs.next()) {
  2177.                     prop = new Proprieta();
  2178.                     prop.setId(rs.getLong("id"));
  2179.                     prop.setNome(rs.getString("nome"));
  2180.                     prop.setValore(rs.getString("valore"));
  2181.                     pa.addProprietaRateLimiting(prop);
  2182.                 }
  2183.                 rs.close();
  2184.                 stm.close();
  2185.                 
  2186.                 
  2187.                 
  2188.                 
  2189.                 
  2190.                 // pa.addSetProperty(setProperty); .....
  2191.                 prop = null;
  2192.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2193.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_PROP);
  2194.                 sqlQueryObject.addSelectField("*");
  2195.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2196.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2197.                 stm = con.prepareStatement(sqlQuery);
  2198.                 stm.setLong(1, idPortaApplicativa);
  2199.                 rs=stm.executeQuery();
  2200.                 while (rs.next()) {
  2201.                     prop = new Proprieta();
  2202.                     prop.setId(rs.getLong("id"));
  2203.                     prop.setNome(rs.getString("nome"));
  2204.                     
  2205.                     String plainValue = rs.getString("valore");
  2206.                     String encValue = rs.getString("enc_value");
  2207.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  2208.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  2209.                         if(driverBYOK!=null) {
  2210.                             prop.setValore(driverBYOK.unwrapAsString(encValue));
  2211.                         }
  2212.                         else {
  2213.                             prop.setValore(encValue);
  2214.                         }
  2215.                     }
  2216.                     else {
  2217.                         prop.setValore(plainValue);
  2218.                     }
  2219.                     
  2220.                     pa.addProprieta(prop);
  2221.                 }
  2222.                 rs.close();
  2223.                 stm.close();
  2224.                 
  2225.                 
  2226.                                 
  2227.                 // ruoli
  2228.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2229.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_RUOLI);
  2230.                 sqlQueryObject.addSelectField("*");
  2231.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2232.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2233.                 stm = con.prepareStatement(sqlQuery);
  2234.                 stm.setLong(1, idPortaApplicativa);
  2235.                 rs = stm.executeQuery();

  2237.                 while (rs.next()) {
  2238.                     
  2239.                     if(pa.getRuoli()==null){
  2240.                         pa.setRuoli(new AutorizzazioneRuoli());
  2241.                     }
  2242.                     
  2243.                     Ruolo ruolo = new Ruolo();
  2244.                     ruolo.setNome(rs.getString("ruolo"));
  2245.                     pa.getRuoli().addRuolo(ruolo);
  2246.                 
  2247.                 }
  2248.                 rs.close();
  2249.                 stm.close();
  2250.                 
  2251.                 
  2252.                 
  2253.                 
  2254.                 // scope
  2255.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2256.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SCOPE);
  2257.                 sqlQueryObject.addSelectField("*");
  2258.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2259.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2260.                 stm = con.prepareStatement(sqlQuery);
  2261.                 stm.setLong(1, idPortaApplicativa);
  2262.                 rs = stm.executeQuery();

  2264.                 while (rs.next()) {
  2265.                     
  2266.                     if(pa.getScope()==null){
  2267.                         pa.setScope(new AutorizzazioneScope());
  2268.                     }
  2269.                     
  2270.                     Scope scope = new Scope();
  2271.                     scope.setNome(rs.getString("scope"));
  2272.                     pa.getScope().addScope(scope);
  2273.                 
  2274.                 }
  2275.                 rs.close();
  2276.                 stm.close();
  2277.                 
  2278.                 
  2279.                 
  2280.                 // soggetti
  2281.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2282.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SOGGETTI);
  2283.                 sqlQueryObject.addSelectField("*");
  2284.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2285.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2286.                 stm = con.prepareStatement(sqlQuery);
  2287.                 stm.setLong(1, idPortaApplicativa);
  2288.                 rs = stm.executeQuery();

  2290.                 while (rs.next()) {
  2291.                     
  2292.                     if(pa.getSoggetti()==null){
  2293.                         pa.setSoggetti(new PortaApplicativaAutorizzazioneSoggetti());
  2294.                     }
  2295.                     
  2296.                     PortaApplicativaAutorizzazioneSoggetto soggetto = new PortaApplicativaAutorizzazioneSoggetto();
  2297.                     soggetto.setTipo(rs.getString("tipo_soggetto"));
  2298.                     soggetto.setNome(rs.getString("nome_soggetto"));
  2299.                     pa.getSoggetti().addSoggetto(soggetto);
  2300.                 
  2301.                 }
  2302.                 rs.close();
  2303.                 stm.close();
  2304.                 
  2305.                 
  2306.                 
  2307.                 // applicativi autorizzti
  2308.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2309.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA_AUTORIZZATI);
  2310.                 sqlQueryObject.addSelectField("*");
  2311.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2312.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2313.                 stm = con.prepareStatement(sqlQuery);
  2314.                 stm.setLong(1, idPortaApplicativa);
  2315.                 rs = stm.executeQuery();

  2317.                 // per ogni entry con id_porta == idPortaApplicativa
  2318.                 // prendo l'id del servizio associato, recupero il nome e
  2319.                 // aggiungo
  2320.                 // il servizio applicativo alla PortaDelegata da ritornare
  2321.                 while (rs.next()) {
  2322.                     long idSaAutorizzato = rs.getLong("id_servizio_applicativo");

  2324.                     if (idSaAutorizzato != 0) {
  2325.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2326.                         sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2327.                         sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  2328.                         sqlQueryObject.addSelectField("nome");
  2329.                         sqlQueryObject.addSelectField("tipo_soggetto");
  2330.                         sqlQueryObject.addSelectField("nome_soggetto");
  2331.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id=?");
  2332.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  2333.                         sqlQueryObject.setANDLogicOperator(true);
  2334.                         sqlQuery = sqlQueryObject.createSQLQuery();
  2335.                         stm1 = con.prepareStatement(sqlQuery);
  2336.                         stm1.setLong(1, idSaAutorizzato);

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

  2340.                         rs1 = stm1.executeQuery();

  2342.                         PortaApplicativaAutorizzazioneServizioApplicativo servizioApplicativo = null;
  2343.                         if (rs1.next()) {
  2344.                             // setto solo il nome come da specifica
  2345.                             servizioApplicativo = new PortaApplicativaAutorizzazioneServizioApplicativo();
  2346.                             servizioApplicativo.setId(idSaAutorizzato);
  2347.                             servizioApplicativo.setNome(rs1.getString("nome"));
  2348.                             servizioApplicativo.setTipoSoggettoProprietario(rs1.getString("tipo_soggetto"));
  2349.                             servizioApplicativo.setNomeSoggettoProprietario(rs1.getString("nome_soggetto"));
  2350.                             if(pa.getServiziApplicativiAutorizzati()==null) {
  2351.                                 pa.setServiziApplicativiAutorizzati(new PortaApplicativaAutorizzazioneServiziApplicativi());
  2352.                             }
  2353.                             pa.getServiziApplicativiAutorizzati().addServizioApplicativo(servizioApplicativo);
  2354.                         }
  2355.                         rs1.close();
  2356.                         stm1.close();
  2357.                     }
  2358.                 }
  2359.                 rs.close();
  2360.                 stm.close();
  2361.                 
  2362.                 
  2363.                 
  2364.                 
  2365.                 // applicativi autorizzti via token
  2366.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2367.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TOKEN_SA);
  2368.                 sqlQueryObject.addSelectField("*");
  2369.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2370.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2371.                 stm = con.prepareStatement(sqlQuery);
  2372.                 stm.setLong(1, idPortaApplicativa);
  2373.                 rs = stm.executeQuery();

  2375.                 // per ogni entry con id_porta == idPortaApplicativa
  2376.                 // prendo l'id del servizio associato, recupero il nome e
  2377.                 // aggiungo
  2378.                 // il servizio applicativo alla PortaDelegata da ritornare
  2379.                 while (rs.next()) {
  2380.                     long idSaAutorizzato = rs.getLong("id_servizio_applicativo");

  2382.                     if (idSaAutorizzato != 0) {
  2383.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2384.                         sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  2385.                         sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  2386.                         sqlQueryObject.addSelectField("nome");
  2387.                         sqlQueryObject.addSelectField("tipo_soggetto");
  2388.                         sqlQueryObject.addSelectField("nome_soggetto");
  2389.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id=?");
  2390.                         sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  2391.                         sqlQueryObject.setANDLogicOperator(true);
  2392.                         sqlQuery = sqlQueryObject.createSQLQuery();
  2393.                         stm1 = con.prepareStatement(sqlQuery);
  2394.                         stm1.setLong(1, idSaAutorizzato);

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

  2398.                         rs1 = stm1.executeQuery();

  2400.                         PortaApplicativaAutorizzazioneServizioApplicativo servizioApplicativo = null;
  2401.                         if (rs1.next()) {
  2402.                             // setto solo il nome come da specifica
  2403.                             servizioApplicativo = new PortaApplicativaAutorizzazioneServizioApplicativo();
  2404.                             servizioApplicativo.setId(idSaAutorizzato);
  2405.                             servizioApplicativo.setNome(rs1.getString("nome"));
  2406.                             servizioApplicativo.setTipoSoggettoProprietario(rs1.getString("tipo_soggetto"));
  2407.                             servizioApplicativo.setNomeSoggettoProprietario(rs1.getString("nome_soggetto"));
  2408.                             if(pa.getAutorizzazioneToken()==null) {
  2409.                                 pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  2410.                             }
  2411.                             if(pa.getAutorizzazioneToken().getServiziApplicativi()==null) {
  2412.                                 pa.getAutorizzazioneToken().setServiziApplicativi(new PortaApplicativaAutorizzazioneServiziApplicativi());
  2413.                             }
  2414.                             pa.getAutorizzazioneToken().getServiziApplicativi().addServizioApplicativo(servizioApplicativo);
  2415.                         }
  2416.                         rs1.close();
  2417.                         stm1.close();
  2418.                     }
  2419.                 }
  2420.                 rs.close();
  2421.                 stm.close();
  2422.                 
  2423.                 
  2424.                 
  2425.                 // ruoli (token)
  2426.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2427.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI);
  2428.                 sqlQueryObject.addSelectField("*");
  2429.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2430.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2431.                 stm = con.prepareStatement(sqlQuery);
  2432.                 stm.setLong(1, idPortaApplicativa);
  2433.                 rs = stm.executeQuery();

  2435.                 while (rs.next()) {
  2436.                     
  2437.                     if(pa.getAutorizzazioneToken()==null) {
  2438.                         pa.setAutorizzazioneToken(new PortaApplicativaAutorizzazioneToken());
  2439.                     }
  2440.                     if(pa.getAutorizzazioneToken().getRuoli()==null){
  2441.                         pa.getAutorizzazioneToken().setRuoli(new AutorizzazioneRuoli());
  2442.                     }
  2443.                     
  2444.                     Ruolo ruolo = new Ruolo();
  2445.                     ruolo.setNome(rs.getString("ruolo"));
  2446.                     pa.getAutorizzazioneToken().getRuoli().addRuolo(ruolo);
  2447.                 
  2448.                 }
  2449.                 rs.close();
  2450.                 stm.close();
  2451.                 
  2452.                 

  2454.                 
  2455.                 // dump_config
  2456.                 DumpConfigurazione dumpConfig = DriverConfigurazioneDB_dumpLIB.readDumpConfigurazione(con, pa.getId(), CostantiDB.DUMP_CONFIGURAZIONE_PROPRIETARIO_PA);
  2457.                 pa.setDump(dumpConfig);
  2458.                 
  2459.                 
  2460.                 // Handlers
  2461.                 ConfigurazioneMessageHandlers requestHandlers = DriverConfigurazioneDB_handlerLIB.readConfigurazioneMessageHandlers(con, null, pa.getId(), true);
  2462.                 ConfigurazioneMessageHandlers responseHandlers = DriverConfigurazioneDB_handlerLIB.readConfigurazioneMessageHandlers(con, null, pa.getId(), false);
  2463.                 if(requestHandlers!=null || responseHandlers!=null) {
  2464.                     pa.setConfigurazioneHandler(new ConfigurazionePortaHandler());
  2465.                     pa.getConfigurazioneHandler().setRequest(requestHandlers);
  2466.                     pa.getConfigurazioneHandler().setResponse(responseHandlers);
  2467.                 }
  2468.                 
  2469.                 
  2470.                 
  2471.                 // attributeAuthority
  2472.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2473.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_ATTRIBUTE_AUTHORITY);
  2474.                 sqlQueryObject.addSelectField("*");
  2475.                 sqlQueryObject.addWhereCondition("id_porta=?");
  2476.                 sqlQuery = sqlQueryObject.createSQLQuery();
  2477.                 stm = con.prepareStatement(sqlQuery);
  2478.                 stm.setLong(1, idPortaApplicativa);
  2479.                 rs = stm.executeQuery();

  2481.                 while (rs.next()) {
  2482.                     
  2483.                     String nome = rs.getString("nome");
  2484.                     String attributi = rs.getString("attributi");
  2485.                     AttributeAuthority aa = new AttributeAuthority();
  2486.                     aa.setNome(nome);
  2487.                     aa.setAttributoList(DBUtils.convertToList(attributi));
  2488.                     pa.addAttributeAuthority(aa);
  2489.                 
  2490.                 }
  2491.                 rs.close();
  2492.                 stm.close();
  2493.                 
  2494.                 
  2495.                 
  2496.                 
  2497.                 // *** Aggiungo extInfo ***
  2498.                 
  2499.                 this.driver.logDebug("ExtendedInfo ... ");
  2500.                 ExtendedInfoManager extInfoManager = ExtendedInfoManager.getInstance();
  2501.                 IExtendedInfo extInfoConfigurazioneDriver = extInfoManager.newInstanceExtendedInfoPortaApplicativa();
  2502.                 if(extInfoConfigurazioneDriver!=null){
  2503.                     List<Object> listExtInfo = extInfoConfigurazioneDriver.getAllExtendedInfo(con, this.driver.log, pa);
  2504.                     if(listExtInfo!=null && !listExtInfo.isEmpty()){
  2505.                         for (Object object : listExtInfo) {
  2506.                             pa.addExtendedInfo(object);
  2507.                         }
  2508.                     }
  2509.                 }

  2511.                 
  2512.                 return pa;
  2513.             } else {
  2514.                 throw new DriverConfigurazioneNotFound("Porta Applicativa non esistente");
  2515.             }
  2516.         } catch (SQLException se) {
  2517.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] SqlException: " + se.getMessage(),se);
  2518.         } catch (DriverConfigurazioneNotFound e) {
  2519.             throw new DriverConfigurazioneNotFound(e);
  2520.         }catch (Exception se) {
  2521.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPortaApplicativa] Exception: " + se.getMessage(),se);
  2522.         }finally {
  2523.             //Chiudo statement and resultset
  2524.             JDBCUtilities.closeResources(rs, stm);
  2525.             JDBCUtilities.closeResources(rs1, stm1);
  2526.             this.driver.closeConnection(conParam, con);
  2527.         }
  2528.     }
  2529.     
  2530.     protected List<String> nomiProprietaPA(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoServiziProtocollo) throws DriverConfigurazioneException {
  2531.         String queryString;

  2533.         Connection con = null;
  2534.         PreparedStatement stmt=null;
  2535.         ResultSet risultato=null;
  2536.         ArrayList<String> lista = new ArrayList<>();

  2538.         if (this.driver.atomica) {
  2539.             try {
  2540.                 con = this.driver.getConnectionFromDatasource("nomiProprietaPA");
  2541.             } catch (Exception e) {
  2542.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::nomiProprietaPA] Exception accedendo al datasource :" + e.getMessage(),e);

  2544.             }

  2546.         } else
  2547.             con = this.driver.globalConnection;

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

  2551.         try {

  2553.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2554.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_PROP);
  2555.             sqlQueryObject.setSelectDistinct(true);
  2556.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE_PROP + ".nome");
  2557.             sqlQueryObject.addOrderBy(CostantiDB.PORTE_APPLICATIVE_PROP + ".nome"); 
  2558.             sqlQueryObject.setSortType(true);
  2559.             sqlQueryObject.setANDLogicOperator(true);
  2560.             
  2561.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome)) || (tipoServiziProtocollo != null && tipoServiziProtocollo.size() > 0)) {
  2562.                 sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  2563.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2564.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  2565.                 
  2566.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_PROP+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  2567.                 sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  2568.                 sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_EROGAZIONE_PA+".id_erogazione="+CostantiDB.SERVIZI+".id");
  2569.                 
  2570.             }
  2571.             
  2572.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome))) {
  2573.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  2574.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  2575.                 
  2576.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto=?");
  2577.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto=?");
  2578.             }
  2579.             
  2580.             if((tipoServiziProtocollo != null && tipoServiziProtocollo.size() > 0)) {
  2581.                 String [] tipiServiziProtocolloS = tipoServiziProtocollo.toArray(new String[tipoServiziProtocollo.size()]); 
  2582.                 sqlQueryObject.addWhereINCondition(CostantiDB.SERVIZI+".tipo_servizio", true, tipiServiziProtocolloS);
  2583.             }
  2584.                 
  2585.             queryString = sqlQueryObject.createSQLQuery();
  2586.             stmt = con.prepareStatement(queryString);
  2587.             if((filterSoggettoNome!=null && !"".equals(filterSoggettoNome))) {
  2588.                 stmt.setString(1, filterSoggettoTipo);
  2589.                 stmt.setString(2, filterSoggettoNome);
  2590.             }
  2591.             risultato = stmt.executeQuery();
  2592.             while (risultato.next()) {
  2593.                 lista.add(risultato.getString("nome"));
  2594.             }
  2595.             return lista;
  2596.         } catch (Exception qe) {
  2597.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::nomiProprietaPA] Errore : " + qe.getMessage(),qe);
  2598.         } finally {
  2599.             //Chiudo statement and resultset
  2600.             JDBCUtilities.closeResources(risultato, stmt);
  2601.             this.driver.closeConnection(con);
  2602.         }
  2603.     }
  2604.     
  2605.     protected List<String> porteApplicativeRateLimitingValoriUnivoci(String pName) throws DriverConfigurazioneException {
  2606.         
  2607.         Connection con = null;
  2608.         PreparedStatement stmt=null;
  2609.         ResultSet risultato=null;
  2610.         ArrayList<String> lista = new ArrayList<>();

  2612.         if (this.driver.atomica) {
  2613.             try {
  2614.                 con = this.driver.getConnectionFromDatasource("porteApplicativeRateLimitingValoriUnivoci");
  2615.             } catch (Exception e) {
  2616.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::porteApplicativeRateLimitingValoriUnivoci] Exception accedendo al datasource :" + e.getMessage(),e);

  2618.             }

  2620.         } else
  2621.             con = this.driver.globalConnection;

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

  2625.         try {

  2627.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2628.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_RATE_LIMITING_PROP);
  2629.             sqlQueryObject.setSelectDistinct(true);
  2630.             sqlQueryObject.addSelectField("valore");
  2631.             sqlQueryObject.addWhereCondition("nome = ?");
  2632.             sqlQueryObject.setANDLogicOperator(true);
  2633.             String queryString = sqlQueryObject.createSQLQuery();
  2634.             
  2635.             stmt = con.prepareStatement(queryString);
  2636.             stmt.setString(1, pName);
  2637.             risultato = stmt.executeQuery();
  2638.             while (risultato.next()) {
  2639.                 lista.add(risultato.getString("valore"));
  2640.             }
  2641.             risultato.close();
  2642.             stmt.close();

  2644.             
  2645.             return lista;

  2647.         } catch (Exception qe) {
  2648.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::porteApplicativeRateLimitingValoriUnivoci] Errore : " + qe.getMessage(),qe);
  2649.         } finally {
  2650.             //Chiudo statement and resultset
  2651.             JDBCUtilities.closeResources(risultato, stmt);
  2652.             this.driver.closeConnection(con);
  2653.         }
  2654.     }
  2655.     
  2656.     
  2657.     protected List<PortaApplicativa> porteAppWithServizio(long idSoggettoErogatore, String tipoServizio,String nomeServizio, Integer versioneServizio) throws DriverConfigurazioneException {
  2658.         String nomeMetodo = "porteAppWithTipoNomeServizio";
  2659.         String queryString;

  2661.         Connection con = null;
  2662.         PreparedStatement stmt=null;
  2663.         ResultSet risultato=null;
  2664.         ArrayList<PortaApplicativa> lista = new ArrayList<>();

  2666.         if (this.driver.atomica) {
  2667.             try {
  2668.                 con = this.driver.getConnectionFromDatasource("porteAppWithTipoNomeServizio");
  2669.             } catch (Exception e) {
  2670.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2672.             }

  2674.         } else
  2675.             con = this.driver.globalConnection;

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

  2679.         try {

  2681.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2682.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2683.             sqlQueryObject.addSelectField("*");
  2684.             sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  2685.             sqlQueryObject.addWhereCondition("servizio = ?");
  2686.             sqlQueryObject.addWhereCondition("versione_servizio = ?");
  2687.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  2688.             sqlQueryObject.setANDLogicOperator(true);
  2689.             queryString = sqlQueryObject.createSQLQuery();
  2690.             stmt = con.prepareStatement(queryString);
  2691.             int index = 1;
  2692.             stmt.setString(index++, tipoServizio);
  2693.             stmt.setString(index++, nomeServizio);
  2694.             stmt.setInt(index++, versioneServizio);
  2695.             stmt.setLong(index++, idSoggettoErogatore);
  2696.             risultato = stmt.executeQuery();

  2698.             PortaApplicativa pa;
  2699.             while (risultato.next()) {
  2700.                 pa = getPortaApplicativa(risultato.getLong("id"),con);
  2701.                 lista.add(pa);
  2702.             }

  2704.             return lista;

  2706.         } catch (Exception qe) {
  2707.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2708.         } finally {

  2710.             //Chiudo statement and resultset
  2711.             JDBCUtilities.closeResources(risultato, stmt);

  2713.             this.driver.closeConnection(con);
  2714.         }
  2715.     }

  2717.     protected List<PortaApplicativa> porteAppWithIdServizio(long idServizio) throws DriverConfigurazioneException {
  2718.         String nomeMetodo = "porteAppWithIdServizio";
  2719.         String queryString;

  2721.         Connection con = null;
  2722.         PreparedStatement stmt=null;
  2723.         ResultSet risultato=null;
  2724.         ArrayList<PortaApplicativa> lista = new ArrayList<>();

  2726.         if (this.driver.atomica) {
  2727.             try {
  2728.                 con = this.driver.getConnectionFromDatasource("porteAppWithIdServizio");
  2729.             } catch (Exception e) {
  2730.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2732.             }

  2734.         } else
  2735.             con = this.driver.globalConnection;

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

  2739.         try {

  2741.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2742.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2743.             sqlQueryObject.addSelectField("*");
  2744.             sqlQueryObject.addWhereCondition("id_servizio = ?");
  2745.             queryString = sqlQueryObject.createSQLQuery();
  2746.             stmt = con.prepareStatement(queryString);
  2747.             stmt.setLong(1, idServizio);
  2748.             risultato = stmt.executeQuery();

  2750.             PortaApplicativa pa;
  2751.             while (risultato.next()) {
  2752.                 pa = getPortaApplicativa(risultato.getLong("id"),con);
  2753.                 lista.add(pa);
  2754.             }

  2756.             return lista;

  2758.         } catch (Exception qe) {
  2759.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2760.         } finally {

  2762.             //Chiudo statement and resultset
  2763.             JDBCUtilities.closeResources(risultato, stmt);

  2765.             this.driver.closeConnection(con);
  2766.         }
  2767.     }
  2768.     
  2769.     protected boolean existsPortaApplicativa(IDPortaApplicativa idPA) throws DriverConfigurazioneException {

  2771.         try{
  2772.             return getPortaApplicativa(idPA)!=null;
  2773.         }catch (DriverConfigurazioneNotFound e) {
  2774.             return false;
  2775.         }
  2776.     }

  2778.     

  2780.     protected List<PortaApplicativa> getPorteApplicativeWithServizio(Long idServizio, String tiposervizio, String nomeservizio, Integer versioneServizio,
  2781.             Long idSoggetto, String tiposoggetto, String nomesoggetto) throws DriverConfigurazioneException {

  2783.         Connection con = null;
  2784.         PreparedStatement stm = null;
  2785.         ResultSet rs = null;
  2786.         String sqlQuery = "";
  2787.         ArrayList<PortaApplicativa> lista = new ArrayList<PortaApplicativa>();

  2789.         try {
  2790.             
  2791.             if (this.driver.atomica) {
  2792.                 try {
  2793.                     con = this.driver.getConnectionFromDatasource("getPorteApplicativeWithServizio");
  2794.                 } catch (Exception e) {
  2795.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeWithServizio] Exception accedendo al datasource :" + e.getMessage(),e);

  2797.                 }

  2799.             } else
  2800.                 con = this.driver.globalConnection;
  2801.             
  2802.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2803.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2804.             sqlQueryObject.addSelectField("*");
  2805.             sqlQueryObject.addWhereCondition(false, "id_servizio = ?", "tipo_servizio = ? AND servizio = ? AND versione_servizio = ?");
  2806.             sqlQueryObject.addWhereCondition(false, "id_soggetto = ?", "id_soggetto_virtuale = ?", "tipo_soggetto_virtuale = ? AND nome_soggetto_virtuale = ?");
  2807.             sqlQueryObject.setANDLogicOperator(true);
  2808.             sqlQuery = sqlQueryObject.createSQLQuery();
  2809.             stm = con.prepareStatement(sqlQuery);

  2811.             int index = 1;
  2812.             stm.setLong(index++, idServizio);
  2813.             stm.setString(index++, tiposervizio);
  2814.             stm.setString(index++, nomeservizio);
  2815.             stm.setInt(index++, versioneServizio);
  2816.             stm.setLong(index++, idSoggetto);
  2817.             stm.setLong(index++, idSoggetto);
  2818.             stm.setString(index++, tiposoggetto);
  2819.             stm.setString(index++, nomesoggetto);

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

  2824.             while (rs.next()) {
  2825.                 PortaApplicativa pa = new PortaApplicativa();
  2826.                 pa.setNome(rs.getString("nome_porta"));
  2827.                 lista.add(pa);
  2828.             }

  2830.             return lista;
  2831.         } catch (Exception qe) {
  2832.             throw new DriverConfigurazioneException(qe);
  2833.         } finally {

  2835.             JDBCUtilities.closeResources(rs, stm);
  2836.             
  2837.             this.driver.closeConnection(con);

  2839.         }

  2841.     }

  2843.     protected PortaApplicativa getPortaApplicativaWithSoggettoAndServizio(String nome, Long idSoggetto, Long idServizio, 
  2844.             String tipoServizio, String nomeServizio, Integer versioneServizio) throws DriverConfigurazioneException {

  2846.         Connection con = null;
  2847.         PreparedStatement stm = null;
  2848.         ResultSet rs = null;
  2849.         String sqlQuery = "";
  2850.         PortaApplicativa pa = new PortaApplicativa();

  2852.         try {
  2853.             
  2854.             if (this.driver.atomica) {
  2855.                 try {
  2856.                     con = this.driver.getConnectionFromDatasource("getPortaApplicativaWithSoggettoAndServizio");
  2857.                 } catch (Exception e) {
  2858.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeWithSoggettoAndServizio] Exception accedendo al datasource :" + e.getMessage(),e);

  2860.                 }

  2862.             } else
  2863.                 con = this.driver.globalConnection;
  2864.             
  2865.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2866.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2867.             sqlQueryObject.addSelectField("*");
  2868.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  2869.             sqlQueryObject.addWhereCondition(false, "id_soggetto = ? AND tipo_servizio = ? AND servizio=? AND versione_servizio=? AND id_soggetto_virtuale <= ?",
  2870.                     "id_soggetto = ? AND id_servizio = ? AND id_soggetto_virtuale <= ?", 
  2871.                     "id_soggetto_virtuale = ? AND tipo_servizio = ? AND servizio=? AND versione_servizio=? ",
  2872.                     "id_soggetto_virtuale = ? AND id_servizio = ?");
  2873.             sqlQueryObject.setANDLogicOperator(true);
  2874.             sqlQuery = sqlQueryObject.createSQLQuery();
  2875.             stm = con.prepareStatement(sqlQuery);

  2877.             int index = 1;
  2878.             
  2879.             stm.setString(index++, nome);

  2881.             stm.setLong(index++, idSoggetto);
  2882.             stm.setString(index++, tipoServizio);
  2883.             stm.setString(index++, nomeServizio);
  2884.             stm.setInt(index++, versioneServizio);
  2885.             stm.setLong(index++, 0);

  2887.             stm.setLong(index++, idSoggetto);
  2888.             stm.setLong(index++, idServizio);
  2889.             stm.setLong(index++, 0);

  2891.             stm.setLong(index++, idSoggetto);
  2892.             stm.setString(index++, tipoServizio);
  2893.             stm.setString(index++, nomeServizio);
  2894.             stm.setInt(index++, versioneServizio);

  2896.             stm.setLong(index++, idSoggetto);
  2897.             stm.setLong(index++, idServizio);

  2899.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idSoggetto, idServizio, -1, idSoggetto, idServizio));
  2900.             rs = stm.executeQuery();

  2902.             if (rs.next()) {
  2903.                 Soggetto sogg = this.soggettiDriver.getSoggetto(rs.getLong("id_soggetto"));
  2904.                 pa.setId(rs.getLong("id"));
  2905.                 pa.setNome(rs.getString("nome_porta"));
  2906.                 pa.setIdSoggetto(rs.getLong("id_soggetto"));
  2907.                 pa.setNomeSoggettoProprietario(sogg.getNome());
  2908.                 pa.setTipoSoggettoProprietario(sogg.getTipo());
  2909.             }else{
  2910.                 throw new Exception("PA non trovata ["+DBUtils.formatSQLString(sqlQuery, idSoggetto, idServizio, -1, idSoggetto, idServizio)+"]");
  2911.             }

  2913.             return pa;
  2914.         } catch (Exception qe) {
  2915.             throw new DriverConfigurazioneException(qe);
  2916.         } finally {

  2918.             JDBCUtilities.closeResources(rs, stm);
  2919.             
  2920.             this.driver.closeConnection(con);

  2922.         }

  2924.     }

  2926.     // NOTA: Metodo non sicuro!!! Possono esistere piu' azioni di port type diversi o accordi diversi !!!!!
  2927.     protected List<IDPortaApplicativa> getPortaApplicativaAzione(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  2928.         Connection con = null;
  2929.         PreparedStatement stm = null;
  2930.         ResultSet rs = null;
  2931.         String sqlQuery = "";

  2933.         List<IDPortaApplicativa> id = new ArrayList<IDPortaApplicativa>();
  2934.         try {

  2936.             if (this.driver.atomica) {
  2937.                 try {
  2938.                     con = this.driver.getConnectionFromDatasource("getPortaApplicativaAzione");
  2939.                 } catch (Exception e) {
  2940.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsPortaApplicativaAzione] Exception accedendo al datasource :" + e.getMessage(),e);

  2942.                 }

  2944.             } else
  2945.                 con = this.driver.globalConnection;
  2946.             
  2947.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  2948.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2949.             sqlQueryObject.addSelectField("*");
  2950.             sqlQueryObject.setANDLogicOperator(true);
  2951.             sqlQueryObject.addWhereCondition("azione=?");
  2952.             sqlQuery = sqlQueryObject.createSQLQuery();
  2953.             stm = con.prepareStatement(sqlQuery);

  2955.             stm.setString(1, nome);

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

  2960.             while (rs.next()){
  2961.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  2962.                 idPA.setNome(rs.getString("nome_porta"));
  2963.                 id.add(idPA);
  2964.             }

  2966.         } catch (Exception qe) {
  2967.             throw new DriverConfigurazioneException(qe);
  2968.         } finally {

  2970.             JDBCUtilities.closeResources(rs, stm);
  2971.             
  2972.             this.driver.closeConnection(con);

  2974.         }

  2976.         if(id.size()>0){
  2977.             return id;
  2978.         }else{
  2979.             throw new DriverConfigurazioneNotFound("Porte Applicative che possiedono l'azione ["+nome+"] non esistenti");
  2980.         }

  2982.     }

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

  2987.         Connection con = null;
  2988.         PreparedStatement stm = null;
  2989.         ResultSet rs = null;
  2990.         String sqlQuery = "";

  2992.         try {
  2993.             
  2994.             if (this.driver.atomica) {
  2995.                 try {
  2996.                     con = this.driver.getConnectionFromDatasource("existsPortaApplicativaAzione");
  2997.                 } catch (Exception e) {
  2998.                     throw new DriverConfigurazioneException("[DriverConfigurazioneDB::existsPortaApplicativaAzione] Exception accedendo al datasource :" + e.getMessage(),e);

  3000.                 }

  3002.             } else
  3003.                 con = this.driver.globalConnection;
  3004.             
  3005.             boolean esiste = false;
  3006.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3007.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3008.             sqlQueryObject.addSelectField("*");
  3009.             sqlQueryObject.addWhereCondition("azione=?");
  3010.             sqlQuery = sqlQueryObject.createSQLQuery();
  3011.             stm = con.prepareStatement(sqlQuery);

  3013.             stm.setString(1, nome);

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

  3018.             if (rs.next())
  3019.                 esiste = true;

  3021.             return esiste;
  3022.         } catch (Exception qe) {
  3023.             throw new DriverConfigurazioneException(qe);
  3024.         } finally {

  3026.             JDBCUtilities.closeResources(rs, stm);
  3027.             
  3028.             this.driver.closeConnection(con);

  3030.         }

  3032.     }
  3033.     
  3034.     
  3035.     
  3036.     protected List<PortaApplicativa> getPorteApplicativaByIdProprietario(long idProprietario) throws DriverConfigurazioneException{
  3037.         Connection con = null;
  3038.         PreparedStatement stm = null;
  3039.         ResultSet rs = null;
  3040.         String sqlQuery = "";

  3042.         if (this.driver.atomica) {
  3043.             try {
  3044.                 con = this.driver.getConnectionFromDatasource("getPorteApplicativaByIdProprietario");
  3045.             } catch (Exception e) {
  3046.                 throw new DriverConfigurazioneException(
  3047.                         "[DriverConfigurazioneDB::getPorteApplicativaByIdProprietario] Exception accedendo al datasource :"
  3048.                                 + e.getMessage(),e);

  3050.             }

  3052.         } else
  3053.             con = this.driver.globalConnection;
  3054.         ArrayList<PortaApplicativa> lista = null;
  3055.         try {

  3057.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3058.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3059.             sqlQueryObject.addSelectField("*");
  3060.             sqlQueryObject.addWhereCondition("id_soggetto=?");
  3061.             sqlQueryObject.setANDLogicOperator(true);
  3062.             sqlQuery = sqlQueryObject.createSQLQuery();
  3063.             stm = con.prepareStatement(sqlQuery);

  3065.             stm.setLong(1, idProprietario);
  3066.             rs = stm.executeQuery();
  3067.             lista=new ArrayList<PortaApplicativa>();
  3068.             while(rs.next()){
  3069.                 long id=rs.getLong("id");
  3070.                 PortaApplicativa pd = this.getPortaApplicativa(id);
  3071.                 lista.add(pd);
  3072.             }

  3074.             return lista;
  3075.         } catch (Exception qe) {
  3076.             throw new DriverConfigurazioneException(qe);
  3077.         } finally {

  3079.             JDBCUtilities.closeResources(rs, stm);
  3080.             
  3081.             this.driver.closeConnection(con);

  3083.         }

  3085.     }

  3087.     /**
  3088.      * Recupera tutte le porte applicative relative al servizio idServizio, erogato dal soggetto erogatore del servizio.
  3089.      * @param idSE
  3090.      * @return List<PortaApplicativa>
  3091.      * @throws DriverConfigurazioneException
  3092.      */
  3093.     protected List<PortaApplicativa> getPorteApplicative(IDServizio idSE) throws DriverConfigurazioneException{
  3094.         Connection con = null;
  3095.         PreparedStatement stm = null;
  3096.         ResultSet rs = null;
  3097.         String sqlQuery = "";

  3099.         if (this.driver.atomica) {
  3100.             try {
  3101.                 con = this.driver.getConnectionFromDatasource("getPorteApplicative(idServizio)");
  3102.             } catch (Exception e) {
  3103.                 throw new DriverConfigurazioneException(
  3104.                         "[DriverConfigurazioneDB::getPorteApplicative] Exception accedendo al datasource :"
  3105.                                 + e.getMessage(),e);

  3107.             }

  3109.         } else
  3110.             con = this.driver.globalConnection;
  3111.         ArrayList<PortaApplicativa> lista = null;
  3112.         try {
  3113.             IDSoggetto erogatore = idSE.getSoggettoErogatore();
  3114.             String tipoServizio = idSE.getTipo();
  3115.             String nomeServizio = idSE.getNome();
  3116.             Integer versioneServizio = idSE.getVersione();

  3118.             long idSoggetto = DBUtils.getIdSoggetto(erogatore.getNome(), erogatore.getTipo(), con, this.driver.tipoDB);
  3119.             long idServizio = DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, erogatore.getNome(), erogatore.getTipo(), con, this.driver.tipoDB);

  3121.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3122.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3123.             sqlQueryObject.addSelectField("*");
  3124.             sqlQueryObject.addWhereCondition("id_soggetto=?");
  3125.             sqlQueryObject.addWhereCondition(false,"id_servizio=?","tipo_servizio=? AND servizio=?");

  3127.             sqlQueryObject.setANDLogicOperator(true);
  3128.             sqlQuery = sqlQueryObject.createSQLQuery();
  3129.             stm = con.prepareStatement(sqlQuery);

  3131.             stm.setLong(1, idSoggetto);
  3132.             stm.setLong(2, idServizio);
  3133.             stm.setString(3, tipoServizio);
  3134.             stm.setString(4, nomeServizio);
  3135.             rs = stm.executeQuery();
  3136.             lista=new ArrayList<PortaApplicativa>();
  3137.             while(rs.next()){
  3138.                 long id=rs.getLong("id");
  3139.                 PortaApplicativa pd = this.getPortaApplicativa(id);
  3140.                 lista.add(pd);
  3141.             }

  3143.             return lista;
  3144.         } catch (Exception qe) {
  3145.             throw new DriverConfigurazioneException(qe);
  3146.         } finally {

  3148.             JDBCUtilities.closeResources(rs, stm);
  3149.             
  3150.             this.driver.closeConnection(con);

  3152.         }

  3154.     }
  3155.     
  3156.     protected List<PortaApplicativa> getPorteApplicativeBySoggetto(long idSoggetto) throws DriverConfigurazioneException {
  3157.         String nomeMetodo = "getPorteApplicativeBySoggetto";

  3159.         Connection con = null;
  3160.         PreparedStatement stmt=null;
  3161.         ResultSet risultato=null;
  3162.         ArrayList<PortaApplicativa> lista = new ArrayList<>();

  3164.         if (this.driver.atomica) {
  3165.             try {
  3166.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  3167.             } catch (Exception e) {
  3168.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3170.             }

  3172.         } else
  3173.             con = this.driver.globalConnection;

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

  3177.         try {

  3179.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3180.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3181.             sqlQueryObject.addSelectField("id");
  3182.             sqlQueryObject.addWhereCondition("id_soggetto=?");
  3183.             String queryString = sqlQueryObject.createSQLQuery();
  3184.             stmt = con.prepareStatement(queryString);
  3185.             stmt.setLong(1, idSoggetto);
  3186.             risultato = stmt.executeQuery();

  3188.             while (risultato.next()) {

  3190.                 Long id = risultato.getLong("id");
  3191.                 lista.add(this.getPortaApplicativa(id));

  3193.             }

  3195.             return lista;

  3197.         } catch (Exception qe) {
  3198.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3199.         } finally {
  3200.             //Chiudo statement and resultset
  3201.             JDBCUtilities.closeResources(risultato, stmt);
  3202.             this.driver.closeConnection(con);
  3203.         }
  3204.     }
  3205.     
  3206.     protected List<PortaApplicativa> getPorteApplicativeBySoggettoVirtuale(IDSoggetto soggettoVirtuale) throws DriverConfigurazioneException {

  3208.         Connection con = null;
  3209.         PreparedStatement stm=null;
  3210.         ResultSet rs=null;
  3211.         ArrayList<PortaApplicativa> lista = new ArrayList<>();

  3213.         if (this.driver.atomica) {
  3214.             try {
  3215.                 con = this.driver.getConnectionFromDatasource("getPorteApplicativeBySoggettoVirtuale");
  3216.             } catch (Exception e) {
  3217.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeBySoggettoVirtuale] Exception accedendo al datasource :" + e.getMessage(),e);

  3219.             }

  3221.         } else
  3222.             con = this.driver.globalConnection;

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

  3226.         try {

  3228.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3229.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3230.             sqlQueryObject.addSelectField("id");
  3231.             sqlQueryObject.addWhereCondition("tipo_soggetto_virtuale is not null");
  3232.             sqlQueryObject.addWhereCondition("nome_soggetto_virtuale is not null");
  3233.             sqlQueryObject.addWhereCondition("tipo_soggetto_virtuale = ?");
  3234.             sqlQueryObject.addWhereCondition("nome_soggetto_virtuale = ?");
  3235.             sqlQueryObject.setANDLogicOperator(true);
  3236.             String queryString = sqlQueryObject.createSQLQuery();

  3238.             stm = con.prepareStatement(queryString);
  3239.             stm.setString(1, soggettoVirtuale.getTipo());
  3240.             stm.setString(2, soggettoVirtuale.getNome());

  3242.             rs = stm.executeQuery();
  3243.             while (rs.next()){
  3244.                 lista.add(getPortaApplicativa(rs.getLong("id"),con));
  3245.             }
  3246.             rs.close();
  3247.             stm.close();

  3249.             return lista;

  3251.         } catch (Exception qe) {
  3252.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getPorteApplicativeBySoggettoVirtuale] Errore : " + qe.getMessage(),qe);
  3253.         } finally {
  3254.             //Chiudo statement and resultset
  3255.             JDBCUtilities.closeResources(rs, stm);

  3257.             this.driver.closeConnection(con);
  3258.         }

  3260.     }
  3261.     
  3262.     protected List<IDPortaApplicativa> getAllIdPorteApplicative(
  3263.             FiltroRicercaPorteApplicative filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  3265.         Connection con = null;
  3266.         PreparedStatement stm = null;
  3267.         ResultSet rs = null;
  3268.         List<String> nomiPA = null;
  3269.         
  3270.         this.driver.logDebug("getAllIdPorteApplicative...");

  3272.         try {
  3273.             this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  3274.             // prendo la connessione dal pool
  3275.             if (this.driver.atomica)
  3276.                 con = this.driver.getConnectionFromDatasource("getAllIdPorteApplicative");
  3277.             else
  3278.                 con = this.driver.globalConnection;

  3280.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3281.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3282.             if(filtroRicerca!=null && (filtroRicerca.getTipoSoggetto()!=null || filtroRicerca.getNomeSoggetto()!=null) ){
  3283.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  3284.             }
  3285.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  3286.             if(filtroRicerca!=null && (filtroRicerca.getTipoSoggetto()!=null || filtroRicerca.getNomeSoggetto()!=null) ){
  3287.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  3288.             }
  3289.             if(filtroRicerca!=null){
  3290.                 if(filtroRicerca.getIdRuolo()!=null){
  3291.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_RUOLI);
  3292.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_RUOLI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3293.                 }
  3294.             }
  3295.             if(filtroRicerca!=null){
  3296.                 if(filtroRicerca.getIdScope()!=null){
  3297.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SCOPE);
  3298.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SCOPE+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3299.                 }
  3300.             }
  3301.             if(filtroRicerca!=null){
  3302.                 if(filtroRicerca.getIdSoggettoAutorizzato()!=null &&
  3303.                         (filtroRicerca.getIdSoggettoAutorizzato().getTipo()!=null || 
  3304.                         filtroRicerca.getIdSoggettoAutorizzato().getNome()!=null)){
  3305.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SOGGETTI);
  3306.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SOGGETTI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3307.                 }
  3308.             }
  3309.             if(filtroRicerca!=null){
  3310.                 if(filtroRicerca.getIdServizioApplicativoAutorizzato()!=null &&
  3311.                         filtroRicerca.getIdServizioApplicativoAutorizzato().getNome()!=null &&
  3312.                         filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario()!=null &&
  3313.                         filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getTipo()!=null &&
  3314.                         filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getNome()!=null
  3315.                         ){
  3316.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA_AUTORIZZATI);                   
  3317.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA_AUTORIZZATI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3318.                 }
  3319.             }
  3320.             if(filtroRicerca!=null){
  3321.                 if(filtroRicerca.getIdServizioApplicativoAutorizzatoToken()!=null &&
  3322.                         filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getNome()!=null &&
  3323.                         filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario()!=null &&
  3324.                         filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getTipo()!=null &&
  3325.                         filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getNome()!=null
  3326.                         ){
  3327.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TOKEN_SA);                 
  3328.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TOKEN_SA+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3329.                 }
  3330.             }
  3331.             if(filtroRicerca!=null){
  3332.                 if(filtroRicerca.getIdRuoloToken()!=null){
  3333.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI);
  3334.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3335.                 }
  3336.             }
  3337.             if(filtroRicerca!=null){
  3338.                 if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione()!=null &&
  3339.                         (filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo()!=null || 
  3340.                         filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome()!=null)){
  3341.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI);
  3342.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI);
  3343.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3344.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI+".id_trasformazione = "+CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id");
  3345.                 }
  3346.             }
  3347.             boolean applicabilitaTrasformazioneTrasporto = false;
  3348.             boolean applicabilitaTrasformazioneSiaTrasportoCheToken = false;
  3349.             if(filtroRicerca!=null){
  3350.                 if(filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione()!=null &&
  3351.                         filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  3352.                         filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario()!=null &&
  3353.                         filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()!=null &&
  3354.                         filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()!=null
  3355.                         ){
  3356.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI);
  3357.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA);
  3358.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3359.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA+".id_trasformazione = "+CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id");
  3360.                     applicabilitaTrasformazioneTrasporto = true;
  3361.                 }
  3362.             }
  3363.             if(filtroRicerca!=null){
  3364.                 if(filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()!=null &&
  3365.                         filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  3366.                         filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario()!=null &&
  3367.                         filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()!=null &&
  3368.                         filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()!=null
  3369.                         ){
  3370.                     if(applicabilitaTrasformazioneTrasporto) {
  3371.                         applicabilitaTrasformazioneSiaTrasportoCheToken = true;
  3372.                     }
  3373.                     else {
  3374.                         sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI);
  3375.                         sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA);
  3376.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3377.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA+".id_trasformazione = "+CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id");
  3378.                     }
  3379.                 }
  3380.             }
  3381.             boolean porteDelegatePerAzioni = false;
  3382.             if(filtroRicerca!=null && filtroRicerca.getNomePortaDelegante()!=null) {
  3383.                 porteDelegatePerAzioni = true;
  3384.                 if(filtroRicerca.getAzione()!=null) {
  3385.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AZIONI);
  3386.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_AZIONI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  3387.                 }
  3388.             }

  3390.             if(filtroRicerca!=null){
  3391.                 // Filtro By Data
  3392.                 if(filtroRicerca.getMinDate()!=null)
  3393.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".ora_registrazione > ?");
  3394.                 if(filtroRicerca.getMaxDate()!=null)
  3395.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".ora_registrazione < ?");
  3396.                 if(filtroRicerca.getTipoSoggetto()!=null)
  3397.                     sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto = ?");
  3398.                 if(filtroRicerca.getNomeSoggetto()!=null)
  3399.                     sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto = ?");
  3400.                 if(filtroRicerca.getTipoSoggettoVirtuale()!=null)
  3401.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_soggetto_virtuale = ?");
  3402.                 if(filtroRicerca.getNomeSoggettoVirtuale()!=null)
  3403.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_soggetto_virtuale = ?");
  3404.                 if(filtroRicerca.getTipoServizio()!=null)
  3405.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_servizio = ?");
  3406.                 if(filtroRicerca.getNomeServizio()!=null)
  3407.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".servizio = ?");
  3408.                 if(filtroRicerca.getVersioneServizio()!=null)
  3409.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".versione_servizio = ?");
  3410.                 if(!porteDelegatePerAzioni && filtroRicerca.getAzione()!=null)
  3411.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".azione = ?");
  3412.                 if(filtroRicerca.getNome()!=null)
  3413.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta = ?");
  3414.                 if(filtroRicerca.getIdRuolo()!=null)
  3415.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_RUOLI+".ruolo = ?");
  3416.                 if(filtroRicerca.getIdScope()!=null)
  3417.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SCOPE+".scope = ?");
  3418.                 if(filtroRicerca.getIdSoggettoAutorizzato()!=null &&
  3419.                         (filtroRicerca.getIdSoggettoAutorizzato().getTipo()!=null || 
  3420.                         filtroRicerca.getIdSoggettoAutorizzato().getNome()!=null)){
  3421.                     if(filtroRicerca.getIdSoggettoAutorizzato().getTipo()!=null) {
  3422.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SOGGETTI+".tipo_soggetto= ?");
  3423.                     }
  3424.                     if(filtroRicerca.getIdSoggettoAutorizzato().getNome()!=null) {
  3425.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SOGGETTI+".nome_soggetto= ?");
  3426.                     }
  3427.                 }
  3428.                 if(filtroRicerca!=null){
  3429.                     if(filtroRicerca.getIdServizioApplicativoAutorizzato()!=null &&
  3430.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getNome()!=null &&
  3431.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario()!=null &&
  3432.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getTipo()!=null &&
  3433.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getNome()!=null
  3434.                             ){
  3435.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA_AUTORIZZATI+".id_servizio_applicativo = ?");
  3436.                     }
  3437.                 }
  3438.                 if(filtroRicerca!=null){
  3439.                     if(filtroRicerca.getIdServizioApplicativoAutorizzatoToken()!=null &&
  3440.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getNome()!=null &&
  3441.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario()!=null &&
  3442.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getTipo()!=null &&
  3443.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getNome()!=null
  3444.                             ){
  3445.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TOKEN_SA+".id_servizio_applicativo = ?");
  3446.                     }
  3447.                 }
  3448.                 if(filtroRicerca.getIdRuoloToken()!=null)
  3449.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI+".ruolo = ?");
  3450.                 if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione()!=null &&
  3451.                         (filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo()!=null || 
  3452.                         filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome()!=null)){
  3453.                     if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo()!=null) {
  3454.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI+".tipo_soggetto= ?");
  3455.                     }
  3456.                     if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome()!=null) {
  3457.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI+".nome_soggetto= ?");
  3458.                     }
  3459.                 }
  3460.                 if(applicabilitaTrasformazioneSiaTrasportoCheToken) {
  3461.                     sqlQueryObject.addWhereCondition(false,
  3462.                             CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA+".id_servizio_applicativo = ?",
  3463.                             CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA+".id_servizio_applicativo = ?");
  3464.                 }
  3465.                 else {
  3466.                     if(filtroRicerca!=null){
  3467.                         if(filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione()!=null &&
  3468.                                 filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  3469.                                 filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario()!=null &&
  3470.                                 filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()!=null &&
  3471.                                 filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()!=null
  3472.                                 ){
  3473.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA+".id_servizio_applicativo = ?");
  3474.                         }
  3475.                     }
  3476.                     if(filtroRicerca!=null){
  3477.                         if(filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()!=null &&
  3478.                                 filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  3479.                                 filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario()!=null &&
  3480.                                 filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()!=null &&
  3481.                                 filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()!=null
  3482.                                 ){
  3483.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA+".id_servizio_applicativo = ?");
  3484.                         }
  3485.                     }
  3486.                 }
  3487.                 if(filtroRicerca.getStato()!=null)
  3488.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".stato = ?");
  3489.                 if(porteDelegatePerAzioni) {
  3490.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta_delegante_azione = ?");
  3491.                     if(filtroRicerca.getAzione()!=null)
  3492.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_AZIONI+".azione = ?");
  3493.                 }
  3494.             }

  3496.             sqlQueryObject.setANDLogicOperator(true);
  3497.             String sqlQuery = sqlQueryObject.createSQLQuery();
  3498.             this.driver.logDebug("eseguo query : " + sqlQuery );
  3499.             stm = con.prepareStatement(sqlQuery);
  3500.             int indexStmt = 1;
  3501.             if(filtroRicerca!=null){
  3502.                 if(filtroRicerca.getMinDate()!=null){
  3503.                     this.driver.logDebug("minDate stmt.setTimestamp("+filtroRicerca.getMinDate()+")");
  3504.                     stm.setTimestamp(indexStmt, new Timestamp(filtroRicerca.getMinDate().getTime()));
  3505.                     indexStmt++;
  3506.                 }
  3507.                 if(filtroRicerca.getMaxDate()!=null){
  3508.                     this.driver.logDebug("maxDate stmt.setTimestamp("+filtroRicerca.getMaxDate()+")");
  3509.                     stm.setTimestamp(indexStmt, new Timestamp(filtroRicerca.getMaxDate().getTime()));
  3510.                     indexStmt++;
  3511.                 }   
  3512.                 if(filtroRicerca.getTipoSoggetto()!=null){
  3513.                     this.driver.logDebug("tipoSoggetto stmt.setString("+filtroRicerca.getTipoSoggetto()+")");
  3514.                     stm.setString(indexStmt, filtroRicerca.getTipoSoggetto());
  3515.                     indexStmt++;
  3516.                 }
  3517.                 if(filtroRicerca.getNomeSoggetto()!=null){
  3518.                     this.driver.logDebug("nomeSoggetto stmt.setString("+filtroRicerca.getNomeSoggetto()+")");
  3519.                     stm.setString(indexStmt, filtroRicerca.getNomeSoggetto());
  3520.                     indexStmt++;
  3521.                 }   
  3522.                 if(filtroRicerca.getTipoSoggettoVirtuale()!=null){
  3523.                     this.driver.logDebug("tipoSoggettoVirtuale stmt.setString("+filtroRicerca.getTipoSoggettoVirtuale()+")");
  3524.                     stm.setString(indexStmt, filtroRicerca.getTipoSoggettoVirtuale());
  3525.                     indexStmt++;
  3526.                 }
  3527.                 if(filtroRicerca.getNomeSoggettoVirtuale()!=null){
  3528.                     this.driver.logDebug("nomeSoggettoVirtuale stmt.setString("+filtroRicerca.getNomeSoggettoVirtuale()+")");
  3529.                     stm.setString(indexStmt, filtroRicerca.getNomeSoggettoVirtuale());
  3530.                     indexStmt++;
  3531.                 }   
  3532.                 if(filtroRicerca.getTipoServizio()!=null){
  3533.                     this.driver.logDebug("tipoServizio stmt.setString("+filtroRicerca.getTipoServizio()+")");
  3534.                     stm.setString(indexStmt, filtroRicerca.getTipoServizio());
  3535.                     indexStmt++;
  3536.                 }
  3537.                 if(filtroRicerca.getNomeServizio()!=null){
  3538.                     this.driver.logDebug("nomeServizio stmt.setString("+filtroRicerca.getNomeServizio()+")");
  3539.                     stm.setString(indexStmt, filtroRicerca.getNomeServizio());
  3540.                     indexStmt++;
  3541.                 }   
  3542.                 if(filtroRicerca.getVersioneServizio()!=null){
  3543.                     this.driver.logDebug("versioneServizio stmt.setInt("+filtroRicerca.getVersioneServizio()+")");
  3544.                     stm.setInt(indexStmt, filtroRicerca.getVersioneServizio());
  3545.                     indexStmt++;
  3546.                 }
  3547.                 if(!porteDelegatePerAzioni && filtroRicerca.getAzione()!=null){
  3548.                     this.driver.logDebug("azione stmt.setString("+filtroRicerca.getAzione()+")");
  3549.                     stm.setString(indexStmt, filtroRicerca.getAzione());
  3550.                     indexStmt++;
  3551.                 }   
  3552.                 if(filtroRicerca.getNome()!=null){
  3553.                     this.driver.logDebug("nome stmt.setString("+filtroRicerca.getNome()+")");
  3554.                     stm.setString(indexStmt, filtroRicerca.getNome());
  3555.                     indexStmt++;
  3556.                 }
  3557.                 if(filtroRicerca.getIdRuolo()!=null){
  3558.                     this.driver.logDebug("ruolo stmt.setString("+filtroRicerca.getIdRuolo().getNome()+")");
  3559.                     stm.setString(indexStmt, filtroRicerca.getIdRuolo().getNome());
  3560.                     indexStmt++;
  3561.                 }
  3562.                 if(filtroRicerca.getIdScope()!=null){
  3563.                     this.driver.logDebug("scope stmt.setString("+filtroRicerca.getIdScope().getNome()+")");
  3564.                     stm.setString(indexStmt, filtroRicerca.getIdScope().getNome());
  3565.                     indexStmt++;
  3566.                 }
  3567.                 if(filtroRicerca.getIdSoggettoAutorizzato()!=null &&
  3568.                         (filtroRicerca.getIdSoggettoAutorizzato().getTipo()!=null || 
  3569.                         filtroRicerca.getIdSoggettoAutorizzato().getNome()!=null)){
  3570.                     if(filtroRicerca.getIdSoggettoAutorizzato().getTipo()!=null) {
  3571.                         this.driver.logDebug("idSoggettoAutorizzazione.tipo stmt.setString("+filtroRicerca.getIdSoggettoAutorizzato().getTipo()+")");
  3572.                         stm.setString(indexStmt, filtroRicerca.getIdSoggettoAutorizzato().getTipo());
  3573.                         indexStmt++;
  3574.                     }
  3575.                     if(filtroRicerca.getIdSoggettoAutorizzato().getNome()!=null) {
  3576.                         this.driver.logDebug("idSoggettoAutorizzazione.nome stmt.setString("+filtroRicerca.getIdSoggettoAutorizzato().getNome()+")");
  3577.                         stm.setString(indexStmt, filtroRicerca.getIdSoggettoAutorizzato().getNome());
  3578.                         indexStmt++;
  3579.                     }
  3580.                 }
  3581.                 if(filtroRicerca!=null){
  3582.                     if(filtroRicerca.getIdServizioApplicativoAutorizzato()!=null &&
  3583.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getNome()!=null &&
  3584.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario()!=null &&
  3585.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getTipo()!=null &&
  3586.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getNome()!=null
  3587.                             ){
  3588.                         long idSA = DBUtils.getIdServizioApplicativo(filtroRicerca.getIdServizioApplicativoAutorizzato().getNome(), 
  3589.                                 filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getTipo(), filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getNome(), con, this.driver.tipoDB);
  3590.                         this.driver.logDebug("idServizioApplicativoAutorizzato stmt.setLong("+idSA
  3591.                                 +") (getIdBy Nome["+filtroRicerca.getIdServizioApplicativoAutorizzato().getNome()
  3592.                                 +"] tipoSoggetto["+filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getTipo()+
  3593.                                 "] nomeSoggetto["+filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getNome()+"])");
  3594.                         stm.setLong(indexStmt, idSA);
  3595.                         indexStmt++;
  3596.                     }
  3597.                 }
  3598.                 if(filtroRicerca!=null){
  3599.                     if(filtroRicerca.getIdServizioApplicativoAutorizzatoToken()!=null &&
  3600.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getNome()!=null &&
  3601.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario()!=null &&
  3602.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getTipo()!=null &&
  3603.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getNome()!=null
  3604.                             ){
  3605.                         long idSA = DBUtils.getIdServizioApplicativo(filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getNome(), 
  3606.                                 filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getTipo(), filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getNome(), con, this.driver.tipoDB);
  3607.                         this.driver.logDebug("idServizioApplicativoAutorizzatoToken stmt.setLong("+idSA
  3608.                                 +") (getIdBy Nome["+filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getNome()
  3609.                                 +"] tipoSoggetto["+filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getTipo()+
  3610.                                 "] nomeSoggetto["+filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getNome()+"])");
  3611.                         stm.setLong(indexStmt, idSA);
  3612.                         indexStmt++;
  3613.                     }
  3614.                 }
  3615.                 if(filtroRicerca.getIdRuoloToken()!=null){
  3616.                     this.driver.logDebug("ruoloToken stmt.setString("+filtroRicerca.getIdRuoloToken().getNome()+")");
  3617.                     stm.setString(indexStmt, filtroRicerca.getIdRuoloToken().getNome());
  3618.                     indexStmt++;
  3619.                 }
  3620.                 if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione()!=null &&
  3621.                         (filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo()!=null || 
  3622.                         filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome()!=null)){
  3623.                     if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo()!=null) {
  3624.                         this.driver.logDebug("idSoggettoTrasformazioni.tipo stmt.setString("+filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo()+")");
  3625.                         stm.setString(indexStmt, filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo());
  3626.                         indexStmt++;
  3627.                     }
  3628.                     if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome()!=null) {
  3629.                         this.driver.logDebug("idSoggettoTrasformazioni.nome stmt.setString("+filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome()+")");
  3630.                         stm.setString(indexStmt, filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome());
  3631.                         indexStmt++;
  3632.                     }
  3633.                 }
  3634.                 if(filtroRicerca!=null){
  3635.                     if(filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione()!=null &&
  3636.                             filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  3637.                             filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario()!=null &&
  3638.                             filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()!=null &&
  3639.                             filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()!=null
  3640.                             ){
  3641.                         long idSA = DBUtils.getIdServizioApplicativo(filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getNome(), 
  3642.                                 filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo(), filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getNome(), con, this.driver.tipoDB);
  3643.                         this.driver.logDebug("idServizioApplicativoTrasformazioni stmt.setLong("+idSA
  3644.                                 +") (getIdBy Nome["+filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getNome()
  3645.                                 +"] tipoSoggetto["+filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()+
  3646.                                 "] nomeSoggetto["+filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()+"])");
  3647.                         stm.setLong(indexStmt, idSA);
  3648.                         indexStmt++;
  3649.                     }
  3650.                 }
  3651.                 if(filtroRicerca!=null){
  3652.                     if(filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()!=null &&
  3653.                             filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  3654.                             filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario()!=null &&
  3655.                             filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()!=null &&
  3656.                             filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()!=null
  3657.                             ){
  3658.                         long idSA = DBUtils.getIdServizioApplicativo(filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getNome(), 
  3659.                                 filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo(), filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getNome(), con, this.driver.tipoDB);
  3660.                         this.driver.logDebug("idServizioApplicativoTokenTrasformazioni stmt.setLong("+idSA
  3661.                                 +") (getIdBy Nome["+filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getNome()
  3662.                                 +"] tipoSoggetto["+filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()+
  3663.                                 "] nomeSoggetto["+filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()+"])");
  3664.                         stm.setLong(indexStmt, idSA);
  3665.                         indexStmt++;
  3666.                     }
  3667.                 }
  3668.                 if(filtroRicerca.getStato()!=null){
  3669.                     this.driver.logDebug("stato stmt.setString("+filtroRicerca.getStato().getValue()+")");
  3670.                     stm.setString(indexStmt, filtroRicerca.getStato().getValue());
  3671.                     indexStmt++;
  3672.                 }
  3673.                 if(porteDelegatePerAzioni) {
  3674.                     this.driver.logDebug("nomePortaDelegata stmt.setString("+filtroRicerca.getNomePortaDelegante()+")");
  3675.                     stm.setString(indexStmt, filtroRicerca.getNomePortaDelegante());
  3676.                     indexStmt++;
  3677.                     if(filtroRicerca.getAzione()!=null) {
  3678.                         this.driver.logDebug("azione stmt.setString("+filtroRicerca.getAzione()+")");
  3679.                         stm.setString(indexStmt, filtroRicerca.getAzione());
  3680.                         indexStmt++;
  3681.                     }
  3682.                 }
  3683.             }
  3684.             rs = stm.executeQuery();
  3685.             nomiPA = new ArrayList<>();
  3686.             while (rs.next()) {
  3687.                 nomiPA.add(rs.getString("nome_porta"));
  3688.             }
  3689.             
  3690.         }catch(Exception e){
  3691.             throw new DriverConfigurazioneException("getAllIdPorteApplicative error",e);
  3692.         } finally {

  3694.             //Chiudo statement and resultset
  3695.             JDBCUtilities.closeResources(rs, stm);

  3697.             this.driver.closeConnection(con);

  3699.         }

  3701.         if(nomiPA == null || nomiPA.size()<=0){
  3702.             if(filtroRicerca!=null)
  3703.                 throw new DriverConfigurazioneNotFound("PorteApplicative non trovate che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  3704.             else
  3705.                 throw new DriverConfigurazioneNotFound("PorteApplicative non trovate");
  3706.         }else{
  3707.             List<IDPortaApplicativa> idsPA = new ArrayList<IDPortaApplicativa>();
  3708.             for (String nomePortaApplicativa : nomiPA) {
  3709.                 idsPA.add(this.getIDPortaApplicativa(nomePortaApplicativa));
  3710.             }
  3711.             return idsPA;
  3712.         }
  3713.     }
  3714.     
  3715.     
  3716.     protected List<IDConnettore> getConnettoriConsegnaNotifichePrioritarie(String queueName) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  3717.         Connection con = null;
  3718.         PreparedStatement stm = null;
  3719.         ResultSet rs = null;

  3721.         this.driver.logDebug("getConnettoriConsegnaNotifichePrioritarie...");

  3723.         try {
  3724.             this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  3725.             // prendo la connessione dal pool
  3726.             if (this.driver.atomica)
  3727.                 con = this.driver.getConnectionFromDatasource("getConnettoriConsegnaNotifichePrioritarie");
  3728.             else
  3729.                 con = this.driver.globalConnection;

  3731.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3732.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  3733.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  3734.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  3735.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI_APPLICATIVI+".nome");
  3736.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".tipo_soggetto");
  3737.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".nome_soggetto");
  3738.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE_SA+".connettore_nome");
  3739.             if(queueName!=null) {
  3740.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".connettore_coda = ?");
  3741.             }
  3742.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".connettore_max_priorita = ?");
  3743.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".id_servizio_applicativo = "+CostantiDB.SERVIZI_APPLICATIVI+".id");
  3744.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  3745.             sqlQueryObject.setANDLogicOperator(true);
  3746.             
  3747.             String sqlQuery = sqlQueryObject.createSQLQuery();
  3748.             this.driver.logDebug("eseguo query : " + sqlQuery );
  3749.             stm = con.prepareStatement(sqlQuery);
  3750.             
  3751.             int indexStmt = 1;
  3752.             if(queueName!=null) {
  3753.                 this.driver.logDebug("queue stmt.setString("+queueName+")");
  3754.                 stm.setString(indexStmt, queueName);
  3755.                 indexStmt++;
  3756.             }
  3757.             this.driver.logDebug("connettore_max_priorita stmt.setInt("+CostantiDB.TRUE+")");
  3758.             stm.setInt(indexStmt, CostantiDB.TRUE);
  3759.             indexStmt++;
  3760.             
  3761.             rs = stm.executeQuery();
  3762.             List<IDConnettore> idsSA = new ArrayList<IDConnettore>();
  3763.             while (rs.next()) {
  3764.                 IDSoggetto idS = new IDSoggetto(rs.getString("tipo_soggetto"),rs.getString("nome_soggetto"));
  3765.                 IDConnettore idSA = new IDConnettore();
  3766.                 idSA.setIdSoggettoProprietario(idS);
  3767.                 idSA.setNome(rs.getString("nome"));
  3768.                 idSA.setNomeConnettore(rs.getString("connettore_nome"));
  3769.                 if(idSA.getNomeConnettore()==null) {
  3770.                     idSA.setNomeConnettore(CostantiConfigurazione.NOME_CONNETTORE_DEFAULT);
  3771.                 }
  3772.                 idsSA.add(idSA);
  3773.             }
  3774.             if(idsSA.size()==0){
  3775.                 if(queueName!=null)
  3776.                     throw new DriverConfigurazioneNotFound("Connettori non trovati per la coda '"+queueName+"'");
  3777.                 else
  3778.                     throw new DriverConfigurazioneNotFound("Connettori non trovati");
  3779.             }else{
  3780.                 return idsSA;
  3781.             }
  3782.         }catch(DriverConfigurazioneNotFound de){
  3783.             throw de;
  3784.         }
  3785.         catch(Exception e){
  3786.             throw new DriverConfigurazioneException("getConnettoriConsegnaNotifichePrioritarie error",e);
  3787.         } finally {

  3789.             //Chiudo statement and resultset
  3790.             JDBCUtilities.closeResources(rs, stm);

  3792.             this.driver.closeConnection(con);

  3794.         }
  3795.     }
  3796.     
  3797.     protected int resetConnettoriConsegnaNotifichePrioritarie(String queueName) throws DriverConfigurazioneException {
  3798.         Connection con = null;
  3799.         PreparedStatement stm = null;
  3800.         
  3801.         this.driver.logDebug("resetConnettoriConsegnaNotifichePrioritarie...");

  3803.         try {
  3804.             this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  3805.             // prendo la connessione dal pool
  3806.             if (this.driver.atomica)
  3807.                 con = this.driver.getConnectionFromDatasource("getConnettoriConsegnaNotifichePrioritarie");
  3808.             else
  3809.                 con = this.driver.globalConnection;

  3811.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3812.             sqlQueryObject.addUpdateTable(CostantiDB.PORTE_APPLICATIVE_SA);
  3813.             sqlQueryObject.addUpdateField("connettore_max_priorita", "?");
  3814.             if(queueName!=null) {
  3815.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".connettore_coda = ?");
  3816.             }
  3817.             sqlQueryObject.setANDLogicOperator(true);
  3818.             
  3819.             String sqlQuery = sqlQueryObject.createSQLUpdate();
  3820.             this.driver.logDebug("eseguo query : " + sqlQuery );
  3821.             stm = con.prepareStatement(sqlQuery);
  3822.             
  3823.             int indexStmt = 1;
  3824.             this.driver.logDebug("connettore_max_priorita stmt.setInt("+CostantiDB.FALSE+")");
  3825.             stm.setInt(indexStmt, CostantiDB.FALSE);
  3826.             indexStmt++;
  3827.             if(queueName!=null) {
  3828.                 this.driver.logDebug("queue stmt.setString("+queueName+")");
  3829.                 stm.setString(indexStmt, queueName);
  3830.                 indexStmt++;
  3831.             }

  3833.             
  3834.             int rows = stm.executeUpdate();
  3835.             return rows;
  3836.             
  3837.         }
  3838.         catch(Exception e){
  3839.             throw new DriverConfigurazioneException("resetConnettoriConsegnaNotifichePrioritarie error",e);
  3840.         } finally {

  3842.             //Chiudo statement and resultset
  3843.             JDBCUtilities.closeResources(stm);

  3845.             this.driver.closeConnection(con);

  3847.         }
  3848.     }
  3849.     
  3850.     protected List<PortaApplicativa> getPorteApplicativeByPolicyGestioneToken(String nome) throws DriverConfigurazioneException{
  3851.         String nomeMetodo = "getPorteApplicativeByPolicyGestioneToken";

  3853.         Connection con = null;
  3854.         PreparedStatement stmt=null;
  3855.         ResultSet risultato=null;
  3856.         ArrayList<PortaApplicativa> lista = new ArrayList<>();

  3858.         if (this.driver.atomica) {
  3859.             try {
  3860.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  3861.             } catch (Exception e) {
  3862.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3864.             }

  3866.         } else
  3867.             con = this.driver.globalConnection;

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

  3871.         try {

  3873.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3874.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3875.             sqlQueryObject.addSelectField("id");
  3876.             sqlQueryObject.addWhereCondition("token_policy=?");
  3877.             String queryString = sqlQueryObject.createSQLQuery();
  3878.             stmt = con.prepareStatement(queryString);
  3879.             stmt.setString(1, nome);
  3880.             risultato = stmt.executeQuery();

  3882.             while (risultato.next()) {

  3884.                 Long id = risultato.getLong("id");
  3885.                 lista.add(this.getPortaApplicativa(id));

  3887.             }

  3889.             return lista;

  3891.         } catch (Exception qe) {
  3892.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3893.         } finally {
  3894.             //Chiudo statement and resultset
  3895.             JDBCUtilities.closeResources(risultato, stmt);
  3896.             this.driver.closeConnection(con);
  3897.         }
  3898.     }
  3899.     
  3900.     protected MappingErogazionePortaApplicativa getMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  3901.         
  3902.         Connection con = null;
  3903.         if (this.driver.atomica) {
  3904.             try {
  3905.                 con = this.driver.getConnectionFromDatasource("getMappingErogazione");

  3907.             } catch (Exception e) {
  3908.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getMappingErogazione] Exception accedendo al datasource :" + e.getMessage(),e);

  3910.             }

  3912.         } else
  3913.             con = this.driver.globalConnection;

  3915.         try {
  3916.             
  3917.             return DBMappingUtils.getMappingErogazione(idServizio, idPortaApplicativa, con, this.driver.tipoDB);

  3919.         } catch (Exception se) {
  3920.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getMappingErogazione] Exception: " + se.getMessage(),se);
  3921.         } finally {
  3922.             
  3923.             this.driver.closeConnection(con);
  3924.         }
  3925.         
  3926.     }
  3927.     
  3928.     protected static List<String> normalizeConnettoriMultpliById(List<String> sa, PortaApplicativa pa){
  3929.         
  3930.         if(pa==null || pa.getBehaviour()==null || pa.sizeServizioApplicativoList()<=0) {
  3931.             return null;
  3932.         }
  3933.         
  3934.         List<String> lId = new ArrayList<>();
  3935.         Map<String, String> m = new HashMap<>();
  3936.         for (String s : sa) {
  3937.             for (PortaApplicativaServizioApplicativo pasa : pa.getServizioApplicativoList()) {
  3938.                 if(pasa!=null && pasa.getNome()!=null && pasa.getNome().equals(s)) {
  3939.                     if(pasa.getId()==null || pasa.getId()<=0) {
  3940.                         return null;
  3941.                     }
  3942.                     long id = pasa.getId();
  3943.                     String nomeConnettore = CostantiConfigurazione.NOME_CONNETTORE_DEFAULT;
  3944.                     if(pasa!=null && pasa.getDatiConnettore()!=null && pasa.getDatiConnettore().getNome()!=null) {
  3945.                         nomeConnettore = pasa.getDatiConnettore().getNome();
  3946.                     }
  3947.                     lId.add(id+"");
  3948.                     m.put(id+"",nomeConnettore);
  3949.                     break;
  3950.                 }
  3951.             }
  3952.         }
  3953.         
  3954.         List<String> sorted = new ArrayList<>();
  3955.         Collections.sort(lId);
  3956.         for (String sId : lId) {
  3957.             sorted.add(m.get(sId));
  3958.         }
  3959.         
  3960.         return sorted;
  3961.     }
  3962.     
  3963.     protected ProprietaOggetto getProprietaOggetto(IDPortaApplicativa idPA) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  3964.         
  3965.         String nomeMetodo = "getProprietaOggetto";
  3966.         
  3967.         if (idPA == null || idPA.getNome()==null)
  3968.             throw new DriverConfigurazioneException("["+nomeMetodo+"] Parametro Non Valido");

  3970.         Connection con = null;
  3971.         PreparedStatement stm = null;
  3972.         ResultSet rs = null;
  3973.         String sqlQuery = "";

  3975.         if (this.driver.atomica) {
  3976.             try {
  3977.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);

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

  3982.             }

  3984.         } else
  3985.             con = this.driver.globalConnection;

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

  3989.         try {
  3990.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  3991.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  3992.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_RICHIEDENTE);
  3993.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_DATA_CREAZIONE);
  3994.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_UTENTE_ULTIMA_MODIFICA);
  3995.             sqlQueryObject.addSelectField(CostantiDB.PROPRIETA_OGGETTO_DATA_ULTIMA_MODIFICA);
  3996.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  3997.             sqlQuery = sqlQueryObject.createSQLQuery();
  3998.             stm = con.prepareStatement(sqlQuery);

  4000.             stm.setString(1, idPA.getNome());

  4002.             this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPA.getNome()));
  4003.             rs = stm.executeQuery();

  4005.             ProprietaOggetto proprieta = null;
  4006.             if (rs.next()) {            
  4007.                 proprieta = this.utilsDriver.readProprietaOggetto(rs, false);
  4008.             }
  4009.             else{
  4010.                 throw new DriverConfigurazioneNotFound("PortaApplicativa ["+idPA.getNome()+"] non esistente");
  4011.             }

  4013.             return proprieta;

  4015.         } catch (SQLException se) {

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

  4020.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::"+nomeMetodo+"] Exception: " + se.getMessage(),se);
  4021.         }
  4022.         finally {

  4024.             //Chiudo statement and resultset
  4025.             JDBCUtilities.closeResources(rs, stm);
  4026.             this.driver.closeConnection(con);
  4027.         }
  4028.     }
  4029.     
  4030.     protected void updateProprietaOggetto(IDPortaApplicativa idPA, String user) throws DriverConfigurazioneException {
  4031.         if(idPA==null || idPA.getNome()==null) {
  4032.             throw new DriverConfigurazioneException("Identificativo non fornito");
  4033.         }
  4034.         this.porteDriver.updateProprietaOggetto(idPA.getNome(), user, CostantiDB.PORTE_APPLICATIVE);
  4035.     }
  4036. }
Created with JaCoCo 0.8.8.202204050719