DBUtils.java

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



  23. package org.openspcoop2.core.commons;

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

  34. import org.openspcoop2.core.constants.CostantiDB;
  35. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  36. import org.openspcoop2.core.constants.TipiConnettore;
  37. import org.openspcoop2.core.id.IDAccordo;
  38. import org.openspcoop2.core.id.IDAccordoCooperazione;
  39. import org.openspcoop2.core.id.IDGruppo;
  40. import org.openspcoop2.core.id.IDRuolo;
  41. import org.openspcoop2.core.id.IDScope;
  42. import org.openspcoop2.core.id.IDServizio;
  43. import org.openspcoop2.core.id.IDSoggetto;
  44. import org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject;
  45. import org.openspcoop2.generic_project.dao.jdbc.utils.GenericJDBCParameterUtilities;
  46. import org.openspcoop2.generic_project.dao.jdbc.utils.JDBCSqlLogger;
  47. import org.openspcoop2.utils.BooleanNullable;
  48. import org.openspcoop2.utils.TipiDatabase;
  49. import org.openspcoop2.utils.UtilsException;
  50. import org.openspcoop2.utils.jdbc.JDBCAdapterException;
  51. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  52. import org.openspcoop2.utils.sql.ISQLQueryObject;
  53. import org.openspcoop2.utils.sql.LikeConfig;
  54. import org.openspcoop2.utils.sql.SQLObjectFactory;
  55. import org.openspcoop2.utils.sql.SQLQueryObjectException;
  56. import org.slf4j.Logger;


  59. /**
  60.  * Funzioni di utilita utilizzate dai driver
  61.  *
  62.  * @author Stefano Corallo (corallo@link.it)
  63.  * @author $Author$
  64.  * @version $Rev$, $Date$
  65.  */
  66. public class DBUtils {

  68.     private DBUtils() {}
  69.     
  70.     private static final String WHERE_ID_CONDITION = "id = ?";
  71.     
  72.     private static boolean keystoreJksPasswordRequired = true;
  73.     private static boolean keystoreJksKeyPasswordRequired = true;
  74.     private static boolean keystorePkcs12PasswordRequired = true;
  75.     private static boolean keystorePkcs12KeyPasswordRequired = true;
  76.     private static boolean truststoreJksPasswordRequired = true;
  77.     private static boolean truststorePkcs12PasswordRequired = true;
  78.     public static boolean isKeystoreJksPasswordRequired() {
  79.         return keystoreJksPasswordRequired;
  80.     }
  81.     public static void setKeystoreJksPasswordRequired(boolean isKeystoreJksPasswordRequired) {
  82.         DBUtils.keystoreJksPasswordRequired = isKeystoreJksPasswordRequired;
  83.     }
  84.     public static boolean isKeystoreJksKeyPasswordRequired() {
  85.         return keystoreJksKeyPasswordRequired;
  86.     }
  87.     public static void setKeystoreJksKeyPasswordRequired(boolean isKeystoreJksKeyPasswordRequired) {
  88.         DBUtils.keystoreJksKeyPasswordRequired = isKeystoreJksKeyPasswordRequired;
  89.     }
  90.     public static boolean isKeystorePkcs12PasswordRequired() {
  91.         return keystorePkcs12PasswordRequired;
  92.     }
  93.     public static void setKeystorePkcs12PasswordRequired(boolean isKeystorePkcs12PasswordRequired) {
  94.         DBUtils.keystorePkcs12PasswordRequired = isKeystorePkcs12PasswordRequired;
  95.     }
  96.     public static boolean isKeystorePkcs12KeyPasswordRequired() {
  97.         return keystorePkcs12KeyPasswordRequired;
  98.     }
  99.     public static void setKeystorePkcs12KeyPasswordRequired(boolean isKeystorePkcs12KeyPasswordRequired) {
  100.         DBUtils.keystorePkcs12KeyPasswordRequired = isKeystorePkcs12KeyPasswordRequired;
  101.     }
  102.     public static boolean isTruststoreJksPasswordRequired() {
  103.         return truststoreJksPasswordRequired;
  104.     }
  105.     public static void setTruststoreJksPasswordRequired(boolean isTruststoreJksPasswordRequired) {
  106.         DBUtils.truststoreJksPasswordRequired = isTruststoreJksPasswordRequired;
  107.     }
  108.     public static boolean isTruststorePkcs12PasswordRequired() {
  109.         return truststorePkcs12PasswordRequired;
  110.     }
  111.     public static void setTruststorePkcs12PasswordRequired(boolean isTruststorePkcs12PasswordRequired) {
  112.         DBUtils.truststorePkcs12PasswordRequired = isTruststorePkcs12PasswordRequired;
  113.     }


  116.     public static String estraiTipoDatabaseFromLocation(String location)throws CoreException{
  117.         if(location==null){
  118.             throw new CoreException("Location del db is null");
  119.         }
  120.         if(location.indexOf("@")==-1){
  121.             throw new CoreException("Tipo di database non indicato nella location, sintassi corretta e' tipoDatabase@datasource");
  122.         }
  123.         String tipoDatabase = location.split("@")[0].trim();
  124.         if( ! TipiDatabase.isAMember(tipoDatabase)){
  125.             throw new CoreException("Tipo di database indicato nella location ["+tipoDatabase+"] non supportato");
  126.         }
  127.         return tipoDatabase;
  128.     }
  129.     
  130.     
  131.     public static List<List<Object>> readCustom(Logger log, Connection connection, String tipoDB,
  132.             ISQLQueryObject sqlQueryObject, List<Class<?>> returnTypes, List<JDBCObject> paramTypes) throws CoreException
  133.     {
  134.         PreparedStatement stm = null;
  135.         ResultSet rs = null;
  136.         try
  137.         {
  138.             if(returnTypes==null || returnTypes.isEmpty()){
  139.                 throw new CoreException("Non sono stati definiti tipi da ritornare");
  140.             }
  141.             
  142.             List<List<Object>> lista = new ArrayList<>();
  143.             
  144.             String sql = sqlQueryObject.createSQLQuery();
  145.             stm=connection.prepareStatement(sql);
  146.             GenericJDBCParameterUtilities jdbcParameterUtilities = new GenericJDBCParameterUtilities(TipiDatabase.toEnumConstant(tipoDB));
  147.             JDBCObject [] paramsArray = null;
  148.             if(paramTypes!=null && !paramTypes.isEmpty()){
  149.                 paramsArray = paramTypes.toArray(new JDBCObject[1]);
  150.             }
  151.             jdbcParameterUtilities.setParameters(stm, paramsArray);
  152.             
  153.             JDBCSqlLogger sqlLogger = new JDBCSqlLogger(log);
  154.             sqlLogger.infoSql(sql, paramsArray);
  155.             
  156.             rs=stm.executeQuery();

  158.             while(rs.next()){
  159.                 
  160.                 List<Object> listaInterna = new ArrayList<>();
  161.                 
  162.                 for (int i = 0; i < returnTypes.size(); i++) {
  163.                     listaInterna.add(jdbcParameterUtilities.readParameter(rs, (i+1), returnTypes.get(i)));
  164.                 }
  165.                 
  166.                 lista.add(listaInterna);
  167.             }

  169.             return lista;

  171.         }catch (Exception e) {
  172.             throw new CoreException(e);
  173.         }finally
  174.         {
  175.             //Chiudo statement and resultset
  176.             JDBCUtilities.closeResources(rs, stm);

  178.         }
  179.     }
  180.     
  181.     
  182.     
  183.     
  184.     /**
  185.      * Recupera l'id del soggetto in base al nome e al tipo passati come parametri
  186.      * @param nomeSoggetto
  187.      * @param tipoSoggetto
  188.      * @param con
  189.      * @return L'id del soggetto se esiste, altrimenti -1
  190.      * @throws CoreException 
  191.      */
  192.     public static long getIdSoggetto(String nomeSoggetto, String tipoSoggetto,Connection con, String tipoDB) throws CoreException
  193.     {
  194.         return DBUtils.getIdSoggetto(nomeSoggetto, tipoSoggetto, con, tipoDB, CostantiDB.SOGGETTI);
  195.     }
  196.     public static long getIdSoggetto(String nomeSoggetto, String tipoSoggetto,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  197.     {
  198.         PreparedStatement stm = null;
  199.         ResultSet rs = null;
  200.         long idSoggetto=-1;
  201.         try
  202.         {
  203.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  204.             sqlQueryObject.addFromTable(tabellaSoggetti);
  205.             sqlQueryObject.addSelectField("*");
  206.             sqlQueryObject.addWhereCondition("tipo_soggetto = ?");
  207.             sqlQueryObject.addWhereCondition("nome_soggetto = ?");
  208.             sqlQueryObject.setANDLogicOperator(true);
  209.             String query = sqlQueryObject.createSQLQuery();
  210.             stm=con.prepareStatement(query);
  211.             stm.setString(1, tipoSoggetto);
  212.             stm.setString(2, nomeSoggetto);

  214.             rs=stm.executeQuery();

  216.             if(rs.next()){
  217.                 idSoggetto = rs.getLong("id");
  218.             }

  220.             return idSoggetto;

  222.         }catch (Exception e) {
  223.             throw new CoreException(e);
  224.         }finally
  225.         {
  226.             //Chiudo statement and resultset
  227.             JDBCUtilities.closeResources(rs, stm);

  229.         }
  230.     }
  231.     
  232.     public static IDSoggetto getIdSoggetto(long id,Connection con, String tipoDB) throws CoreException
  233.     {
  234.         return DBUtils.getIdSoggetto(id, con, tipoDB, CostantiDB.SOGGETTI);
  235.     }
  236.     public static IDSoggetto getIdSoggetto(long id,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  237.     {
  238.         PreparedStatement stm = null;
  239.         ResultSet rs = null;
  240.         IDSoggetto idSoggetto = null;
  241.         try
  242.         {
  243.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  244.             sqlQueryObject.addFromTable(tabellaSoggetti);
  245.             sqlQueryObject.addSelectField("*");
  246.             sqlQueryObject.addWhereCondition(WHERE_ID_CONDITION);
  247.             sqlQueryObject.setANDLogicOperator(true);
  248.             String query = sqlQueryObject.createSQLQuery();
  249.             stm=con.prepareStatement(query);
  250.             stm.setLong(1, id);

  252.             rs=stm.executeQuery();

  254.             if(rs.next()){
  255.                 String tipSoggetto = rs.getString("tipo_soggetto");
  256.                 String nomeSoggetto = rs.getString("nome_soggetto");
  257.                 idSoggetto = new IDSoggetto(tipSoggetto, nomeSoggetto);
  258.             }

  260.             return idSoggetto;

  262.         }catch (Exception e) {
  263.             throw new CoreException(e);
  264.         }finally
  265.         {
  266.             //Chiudo statement and resultset
  267.             JDBCUtilities.closeResources(rs, stm);

  269.         }
  270.     }
  271.     
  272.     
  273.     
  274.     

  276.     public static long getIdConnettore(String nomeConnettore,Connection con, String tipoDB) throws CoreException
  277.     {
  278.         PreparedStatement stm = null;
  279.         ResultSet rs = null;
  280.         long idConnettore=-1;
  281.         try
  282.         {
  283.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  284.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  285.             sqlQueryObject.addSelectField("*");
  286.             sqlQueryObject.addWhereCondition("nome_connettore = ?");
  287.             String query = sqlQueryObject.createSQLQuery();
  288.             stm=con.prepareStatement(query);
  289.             stm.setString(1, nomeConnettore);
  290.             rs=stm.executeQuery();

  292.             if(rs.next()){
  293.                 idConnettore = rs.getLong("id");
  294.             }

  296.             return idConnettore;

  298.         }catch (Exception e) {
  299.             throw new CoreException(e);
  300.         }finally
  301.         {
  302.             //Chiudo statement and resultset
  303.             JDBCUtilities.closeResources(rs, stm);

  305.         }
  306.     }

  308.     
  309.     
  310.     /**
  311.      * Recupero l'id del servizio
  312.      */
  313.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,Connection con, String tipoDB) throws CoreException{
  314.         return DBUtils.getIdServizio(nomeServizio,tipoServizio,versioneServizio,nomeSoggettoErogatore,tipoSoggettoErogatore,con,false,tipoDB, CostantiDB.SOGGETTI);
  315.     }
  316.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  317.         return DBUtils.getIdServizio(nomeServizio,tipoServizio,versioneServizio,nomeSoggettoErogatore,tipoSoggettoErogatore,con,false,tipoDB,tabellaSoggetti);
  318.     }
  319.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, long idSoggetto,Connection con, String tipoDB) throws CoreException{
  320.         return DBUtils.getIdServizio(nomeServizio,tipoServizio,versioneServizio,idSoggetto,con,false,tipoDB, CostantiDB.SOGGETTI);
  321.     }
  322.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, long idSoggetto,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  323.         return DBUtils.getIdServizio(nomeServizio,tipoServizio,versioneServizio,idSoggetto,con,false,tipoDB,tabellaSoggetti);
  324.     }

  326.     /**
  327.      * Recupero l'id del servizio
  328.      */
  329.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,
  330.             Connection con,boolean testServizioNonCorrelato,String tipoDB) throws CoreException
  331.     {
  332.         return DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeSoggettoErogatore, tipoSoggettoErogatore, con, testServizioNonCorrelato, tipoDB, CostantiDB.SOGGETTI);
  333.     }
  334.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,
  335.             Connection con,boolean testServizioNonCorrelato,String tipoDB,String tabellaSoggetti) throws CoreException
  336.     {
  337.         long idSoggetto = DBUtils.getIdSoggetto(nomeSoggettoErogatore, tipoSoggettoErogatore, con, tipoDB,tabellaSoggetti);
  338.         return getIdServizio(nomeServizio, tipoServizio, versioneServizio, idSoggetto,
  339.                 con, testServizioNonCorrelato, tipoDB, tabellaSoggetti);
  340.     }
  341.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, long idSoggetto,
  342.             Connection con,boolean testServizioNonCorrelato,String tipoDB) throws CoreException
  343.     {
  344.         return  getIdServizio(nomeServizio, tipoServizio, versioneServizio, idSoggetto,
  345.                 con,testServizioNonCorrelato,tipoDB,CostantiDB.SOGGETTI);
  346.     }
  347.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, long idSoggetto,
  348.             Connection con,boolean testServizioNonCorrelato,String tipoDB,String tabellaSoggetti) throws CoreException
  349.     {
  350.         PreparedStatement stm = null;
  351.         ResultSet rs = null;
  352.         long idServizio=0;
  353.         try
  354.         {
  355.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  356.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  357.             sqlQueryObject.addSelectField("*");
  358.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  359.             sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  360.             sqlQueryObject.addWhereCondition("nome_servizio = ?");
  361.             sqlQueryObject.addWhereCondition("versione_servizio = ?");
  362.             sqlQueryObject.setANDLogicOperator(true);
  363.             String query = sqlQueryObject.createSQLQuery();
  364.             if(testServizioNonCorrelato)
  365.                 query = query + " AND servizio_correlato=?";
  366.             stm=con.prepareStatement(query);
  367.             int index = 1;
  368.             stm.setLong(index++, idSoggetto);
  369.             stm.setString(index++, tipoServizio);
  370.             stm.setString(index++, nomeServizio);
  371.             stm.setInt(index++, versioneServizio);
  372.             if(testServizioNonCorrelato)
  373.                 stm.setString(index++, CostantiDB.STATO_FUNZIONALITA_DISABILITATO);

  375.             rs=stm.executeQuery();

  377.             if(rs.next()){
  378.                 idServizio = rs.getLong("id");
  379.             }

  381.             return idServizio;

  383.         }catch (Exception e) {
  384.             throw new CoreException(e);
  385.         }finally
  386.         {
  387.             //Chiudo statement and resultset
  388.             JDBCUtilities.closeResources(rs, stm);

  390.         }
  391.     }

  393.     
  394.     
  395.     
  396.     
  397.     
  398.     public static String getSuperUserSoggettoSafe(Logger log, String method,
  399.             long idSoggetto,Connection con, String tipoDB) 
  400.     {
  401.         return getSuperUserSoggettoSafe(log, method,
  402.                 idSoggetto,con, tipoDB,CostantiDB.SOGGETTI);
  403.     }
  404.     public static String getSuperUserSoggettoSafe(Logger log, String method,
  405.             long idSoggetto,Connection con, String tipoDB,String tabellaSoggetti) 
  406.     {
  407.         try
  408.         {
  409.             return getSuperUserSoggetto(idSoggetto, con, tipoDB, tabellaSoggetti);
  410.         }catch(Exception e) {
  411.             if(log!=null) {
  412.                 String msgError = "["+method+"] getSuperUserSoggetto failed: "+e.getMessage();
  413.                 log.error(msgError, e);
  414.             }
  415.             return null;
  416.         }
  417.     }
  418.     public static String getSuperUserSoggetto(long idSoggetto,Connection con, String tipoDB) throws CoreException
  419.     {
  420.         return getSuperUserSoggetto(idSoggetto, con, tipoDB, CostantiDB.SOGGETTI);
  421.     }
  422.     public static String getSuperUserSoggetto(long idSoggetto,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  423.     {
  424.         PreparedStatement stm = null;
  425.         ResultSet rs = null;
  426.         String superuser=null;
  427.         try
  428.         {
  429.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  430.             sqlQueryObject.addFromTable(tabellaSoggetti);
  431.             sqlQueryObject.addSelectField("superuser");
  432.             sqlQueryObject.addWhereCondition(WHERE_ID_CONDITION);
  433.             sqlQueryObject.setANDLogicOperator(true);
  434.             String query = sqlQueryObject.createSQLQuery();
  435.             stm=con.prepareStatement(query);
  436.             stm.setLong(1, idSoggetto);

  438.             rs=stm.executeQuery();

  440.             if(rs.next()){
  441.                 superuser = rs.getString("superuser");
  442.             }

  444.             return superuser;

  446.         }
  447.         catch (Exception e) {
  448.             throw new CoreException(e);
  449.         }finally
  450.         {
  451.             //Chiudo statement and resultset
  452.             JDBCUtilities.closeResources(rs, stm);

  454.         }
  455.     }
  456.     
  457.     
  458.     
  459.     
  460.     
  461.     
  462.     
  463.     
  464.     
  465.     public static String getSuperUserServizioSafe(Logger log, String method,
  466.             long idServizio,Connection con, String tipoDB) 
  467.     {
  468.         try
  469.         {
  470.             return getSuperUserServizio(idServizio, con, tipoDB);
  471.         }catch(Exception e) {
  472.             if(log!=null) {
  473.                 String msgError = "["+method+"] getSuperUserServizio failed: "+e.getMessage();
  474.                 log.error(msgError, e);
  475.             }
  476.             return null;
  477.         }
  478.     }
  479.     public static String getSuperUserServizio(long idServizio,Connection con, String tipoDB) throws CoreException
  480.     {
  481.         PreparedStatement stm = null;
  482.         ResultSet rs = null;
  483.         String superuser=null;
  484.         try
  485.         {
  486.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  487.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  488.             sqlQueryObject.addSelectField("superuser");
  489.             sqlQueryObject.addWhereCondition(WHERE_ID_CONDITION);
  490.             sqlQueryObject.setANDLogicOperator(true);
  491.             String query = sqlQueryObject.createSQLQuery();
  492.             stm=con.prepareStatement(query);
  493.             stm.setLong(1, idServizio);

  495.             rs=stm.executeQuery();

  497.             if(rs.next()){
  498.                 superuser = rs.getString("superuser");
  499.             }

  501.             return superuser;

  503.         }
  504.         catch (Exception e) {
  505.             throw new CoreException(e);
  506.         }finally
  507.         {
  508.             //Chiudo statement and resultset
  509.             JDBCUtilities.closeResources(rs, stm);

  511.         }
  512.     }
  513.     
  514.     
  515.     
  516.     
  517.     
  518.     

  520.     public static long getIdPortaApplicativa(String nomePorta, Connection con, String tipoDB) throws CoreException
  521.     {
  522.         PreparedStatement stm = null;
  523.         ResultSet rs = null;
  524.         long idPortaApplicativa=-1;

  526.         try
  527.         {
  528.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  529.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  530.             sqlQueryObject.addSelectField("id");
  531.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  532.             sqlQueryObject.setANDLogicOperator(true);
  533.             String sqlQuery = sqlQueryObject.createSQLQuery();
  534.             stm=con.prepareStatement(sqlQuery);
  535.             stm.setString(1, nomePorta);

  537.             rs=stm.executeQuery();

  539.             if(rs.next())
  540.             {
  541.                 idPortaApplicativa=rs.getLong("id");
  542.             }
  543.             return idPortaApplicativa;
  544.         }catch (Exception e) {
  545.             throw new CoreException(e);
  546.         }finally
  547.         {
  548.             //Chiudo statement and resultset
  549.             JDBCUtilities.closeResources(rs, stm);

  551.         }

  553.     }
  554.     
  555.     
  556.     
  557.     
  558.     
  559.     
  560.     public static long getIdPortaDelegata(String nomePorta, Connection con, String tipoDB) throws CoreException
  561.     {
  562.         PreparedStatement stm = null;
  563.         ResultSet rs = null;
  564.         long idPortaDelegata=-1;

  566.         try
  567.         {
  568.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  569.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  570.             sqlQueryObject.addSelectField("id");
  571.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  572.             sqlQueryObject.setANDLogicOperator(true);
  573.             String sqlQuery = sqlQueryObject.createSQLQuery();
  574.             stm=con.prepareStatement(sqlQuery);
  575.             stm.setString(1, nomePorta);

  577.             rs=stm.executeQuery();

  579.             if(rs.next())
  580.             {
  581.                 idPortaDelegata=rs.getLong("id");
  582.             }
  583.             return idPortaDelegata;
  584.         }catch (Exception e) {
  585.             throw new CoreException(e);
  586.         }finally
  587.         {
  588.             //Chiudo statement and resultset
  589.             JDBCUtilities.closeResources(rs, stm);

  591.         }

  593.     }
  594.     
  595.     
  596.     
  597.     
  598.     
  599.     
  600.     public static long getIdServizioApplicativo(String nomeServizioApplicativo, String tipoProprietario, String nomeProprietario,
  601.             Connection con, String tipoDB) throws CoreException
  602.     {
  603.         return DBUtils.getIdServizioApplicativo(nomeServizioApplicativo, tipoProprietario, nomeProprietario, con, tipoDB, CostantiDB.SOGGETTI);
  604.     }
  605.     public static long getIdServizioApplicativo(String nomeServizioApplicativo, String tipoProprietario, String nomeProprietario,
  606.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  607.     {
  608.         PreparedStatement stm = null;
  609.         ResultSet rs = null;
  610.         long idSoggetto;
  611.         long idServizioApplicativo=-1;

  613.         try
  614.         {
  615.             idSoggetto = DBUtils.getIdSoggetto(nomeProprietario, tipoProprietario, con, tipoDB,tabellaSoggetti);

  617.             //recupero l'id della porta applicativa appena inserita
  618.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  619.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  620.             sqlQueryObject.addSelectField("id");
  621.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  622.             sqlQueryObject.addWhereCondition("nome = ?");
  623.             sqlQueryObject.setANDLogicOperator(true);
  624.             String sqlQuery = sqlQueryObject.createSQLQuery();
  625.             stm=con.prepareStatement(sqlQuery);
  626.             stm.setLong(1, idSoggetto);
  627.             stm.setString(2, nomeServizioApplicativo);

  629.             rs=stm.executeQuery();

  631.             if(rs.next())
  632.             {
  633.                 idServizioApplicativo=rs.getLong("id");
  634.             }
  635.             return idServizioApplicativo;
  636.         }catch (Exception e) {
  637.             throw new CoreException(e);
  638.         }finally
  639.         {
  640.             //Chiudo statement and resultset
  641.             JDBCUtilities.closeResources(rs, stm);

  643.         }

  645.     }

  647.     
  648.     
  649.     
  650.     
  651.     
  652.     public static long getIdPortaDominio(String nome, Connection con, String tipoDB) throws CoreException
  653.     {
  654.         PreparedStatement stm = null;
  655.         ResultSet rs = null;
  656.         long idPdD=-1;
  657.         try
  658.         {
  659.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  660.             sqlQueryObject.addFromTable(CostantiDB.PDD);
  661.             sqlQueryObject.addSelectField("*");
  662.             sqlQueryObject.addWhereCondition("nome = ?");
  663.             sqlQueryObject.setANDLogicOperator(true);
  664.             String query = sqlQueryObject.createSQLQuery();
  665.             stm=con.prepareStatement(query);
  666.             stm.setString(1, nome);

  668.             rs=stm.executeQuery();

  670.             if(rs.next()){
  671.                 idPdD = rs.getLong("id");
  672.             }

  674.             return idPdD;

  676.         }catch (Exception e) {
  677.             throw new CoreException(e);
  678.         }finally
  679.         {
  680.             //Chiudo statement and resultset
  681.             JDBCUtilities.closeResources(rs, stm);

  683.         }
  684.     }
  685.     
  686.     
  687.     
  688.     
  689.     
  690.     public static long getIdGruppo(IDGruppo idGruppo, Connection con, String tipoDB) throws CoreException
  691.     {
  692.         PreparedStatement stm = null;
  693.         ResultSet rs = null;
  694.         long idGruppoLong=-1;
  695.         try
  696.         {
  697.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  698.             sqlQueryObject.addFromTable(CostantiDB.GRUPPI);
  699.             sqlQueryObject.addSelectField("*");
  700.             sqlQueryObject.addWhereCondition("nome = ?");
  701.             sqlQueryObject.setANDLogicOperator(true);
  702.             String query = sqlQueryObject.createSQLQuery();
  703.             stm=con.prepareStatement(query);
  704.             stm.setString(1, idGruppo.getNome());

  706.             rs=stm.executeQuery();

  708.             if(rs.next()){
  709.                 idGruppoLong = rs.getLong("id");
  710.             }

  712.             return idGruppoLong;

  714.         }catch (Exception e) {
  715.             throw new CoreException(e);
  716.         }finally
  717.         {
  718.             //Chiudo statement and resultset
  719.             JDBCUtilities.closeResources(rs, stm);

  721.         }
  722.     }
  723.     
  724.     
  725.     
  726.     
  727.     
  728.     
  729.     public static long getIdRuolo(IDRuolo idRuolo, Connection con, String tipoDB) throws CoreException
  730.     {
  731.         PreparedStatement stm = null;
  732.         ResultSet rs = null;
  733.         long idRuoloLong=-1;
  734.         try
  735.         {
  736.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  737.             sqlQueryObject.addFromTable(CostantiDB.RUOLI);
  738.             sqlQueryObject.addSelectField("*");
  739.             sqlQueryObject.addWhereCondition("nome = ?");
  740.             sqlQueryObject.setANDLogicOperator(true);
  741.             String query = sqlQueryObject.createSQLQuery();
  742.             stm=con.prepareStatement(query);
  743.             stm.setString(1, idRuolo.getNome());

  745.             rs=stm.executeQuery();

  747.             if(rs.next()){
  748.                 idRuoloLong = rs.getLong("id");
  749.             }

  751.             return idRuoloLong;

  753.         }catch (Exception e) {
  754.             throw new CoreException(e);
  755.         }finally
  756.         {
  757.             //Chiudo statement and resultset
  758.             JDBCUtilities.closeResources(rs, stm);

  760.         }
  761.     }
  762.     
  763.     
  764.     
  765.     
  766.     public static long getIdScope(IDScope idScope, Connection con, String tipoDB) throws CoreException
  767.     {
  768.         PreparedStatement stm = null;
  769.         ResultSet rs = null;
  770.         long idScopeLong=-1;
  771.         try
  772.         {
  773.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  774.             sqlQueryObject.addFromTable(CostantiDB.SCOPE);
  775.             sqlQueryObject.addSelectField("*");
  776.             sqlQueryObject.addWhereCondition("nome = ?");
  777.             sqlQueryObject.setANDLogicOperator(true);
  778.             String query = sqlQueryObject.createSQLQuery();
  779.             stm=con.prepareStatement(query);
  780.             stm.setString(1, idScope.getNome());

  782.             rs=stm.executeQuery();

  784.             if(rs.next()){
  785.                 idScopeLong = rs.getLong("id");
  786.             }

  788.             return idScopeLong;

  790.         }catch (Exception e) {
  791.             throw new CoreException(e);
  792.         }finally
  793.         {
  794.             //Chiudo statement and resultset
  795.             JDBCUtilities.closeResources(rs, stm);

  797.         }
  798.     }
  799.     
  800.     
  801.     
  802.     
  803.     

  805.     public static long getIdAccordoServizioParteComune(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,Connection con, String tipoDB) throws CoreException
  806.     {
  807.         return DBUtils.getIdAccordoServizioParteComune(nomeServizio,tipoServizio,versioneServizio, nomeSoggettoErogatore,tipoSoggettoErogatore,con,tipoDB,CostantiDB.SOGGETTI);
  808.     }
  809.     public static long getIdAccordoServizioParteComune(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  810.     {
  811.         PreparedStatement stm = null;
  812.         ResultSet rs = null;
  813.         long idServizio;
  814.         long idAccordo = -1;
  815.         try
  816.         {
  817.             idServizio = DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeSoggettoErogatore, tipoSoggettoErogatore, con, tipoDB,tabellaSoggetti);

  819.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  820.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  821.             sqlQueryObject.addSelectField("*");
  822.             sqlQueryObject.addWhereCondition(WHERE_ID_CONDITION);
  823.             String query = sqlQueryObject.createSQLQuery();
  824.             stm=con.prepareStatement(query);
  825.             stm.setLong(1, idServizio);

  827.             rs=stm.executeQuery();

  829.             if(rs.next()){
  830.                 idAccordo = rs.getLong("id_accordo");
  831.             }

  833.             return idAccordo;

  835.         }catch (Exception e) {
  836.             throw new CoreException(e);
  837.         }finally
  838.         {
  839.             //Chiudo statement and resultset
  840.             JDBCUtilities.closeResources(rs, stm);

  842.         }
  843.     }
  844.     
  845.     public static long getIdPortType(Long idAccordo,String nomePortType,Connection con) throws CoreException{
  846.         PreparedStatement selectStmt = null;
  847.         ResultSet selectRS = null;
  848.         long id=-1;
  849.         try
  850.         {
  851.             String selectQuery = "SELECT id FROM " + CostantiDB.PORT_TYPE + " WHERE id_accordo = ? AND nome=?";
  852.             selectStmt = con.prepareStatement(selectQuery);
  853.             selectStmt.setLong(1, idAccordo);
  854.             selectStmt.setString(2, nomePortType);
  855.             selectRS = selectStmt.executeQuery();
  856.             if (selectRS.next()) {
  857.                 id = selectRS.getLong("id");    
  858.             }
  859.             selectRS.close();
  860.             selectStmt.close();
  861.             return id;
  862.         }catch (Exception e) {
  863.             throw new CoreException(e);
  864.         }finally
  865.         {
  866.             //Chiudo statement and resultset
  867.             JDBCUtilities.closeResources(selectRS, selectStmt);

  869.         }
  870.     }
  871.     
  872.     public static long getIdResource(Long idAccordo,String nomeRisorsa,Connection con) throws CoreException{
  873.         PreparedStatement selectStmt = null;
  874.         ResultSet selectRS = null;
  875.         long id=-1;
  876.         try
  877.         {
  878.             String selectQuery = "SELECT id FROM " + CostantiDB.API_RESOURCES + " WHERE id_accordo = ? AND nome=?";
  879.             selectStmt = con.prepareStatement(selectQuery);
  880.             selectStmt.setLong(1, idAccordo);
  881.             selectStmt.setString(2, nomeRisorsa);
  882.             selectRS = selectStmt.executeQuery();
  883.             if (selectRS.next()) {
  884.                 id = selectRS.getLong("id");    
  885.             }
  886.             selectRS.close();
  887.             selectStmt.close();
  888.             return id;
  889.         }catch (Exception e) {
  890.             throw new CoreException(e);
  891.         }finally
  892.         {
  893.             //Chiudo statement and resultset
  894.             JDBCUtilities.closeResources(selectRS, selectStmt);

  896.         }
  897.     }
  898.     
  899.     public static long getIdAccordoServizioParteComune(IDAccordo idAccordo,Connection con, String tipoDB) throws CoreException{
  900.         PreparedStatement stm = null;
  901.         ResultSet rs = null;
  902.         long idAccordoLong=-1;
  903.         try
  904.         {
  905.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  906.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  907.             sqlQueryObject.addSelectField("*");
  908.             sqlQueryObject.addWhereCondition("nome = ?");
  909.             sqlQueryObject.addWhereCondition("id_referente = ?");
  910.             sqlQueryObject.addWhereCondition("versione = ?");
  911.             sqlQueryObject.setANDLogicOperator(true);
  912.             String query = sqlQueryObject.createSQLQuery();
  913.             stm=con.prepareStatement(query);
  914.             stm.setString(1, idAccordo.getNome());
  915.             
  916.             long idSoggettoReferente =  0;
  917.             if(idAccordo.getSoggettoReferente()!=null){
  918.                 idSoggettoReferente = DBUtils.getIdSoggetto(idAccordo.getSoggettoReferente().getNome(), idAccordo.getSoggettoReferente().getTipo(), con, tipoDB);
  919.                 if(idSoggettoReferente<=0){
  920.                     throw new CoreException("[getIdAccordoServizioParteComune] Soggetto Referente ["+idAccordo.getSoggettoReferente().toString()+"] non esiste");
  921.                 }
  922.             }
  923.             stm.setLong(2, idSoggettoReferente);
  924.                 
  925.             stm.setInt(3, idAccordo.getVersione());
  926.                         
  927.             rs=stm.executeQuery();

  929.             if(rs.next()){
  930.                 idAccordoLong = rs.getLong("id");
  931.             }

  933.             return idAccordoLong;

  935.         }catch (Exception e) {
  936.             throw new CoreException(e);
  937.         }finally
  938.         {
  939.             //Chiudo statement and resultset
  940.             JDBCUtilities.closeResources(rs, stm);

  942.         }
  943.     }
  944.     
  945.     public static int getAccordoServizioParteComuneNextVersion(IDAccordo idAccordo,Connection con, String tipoDB) throws CoreException{
  946.         PreparedStatement stm = null;
  947.         ResultSet rs = null;
  948.         try
  949.         {
  950.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  951.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  952.             sqlQueryObject.addSelectField("versione");
  953.             sqlQueryObject.addWhereCondition("nome = ?");
  954.             sqlQueryObject.addWhereCondition("id_referente = ?");
  955.             sqlQueryObject.addOrderBy("versione");
  956.             sqlQueryObject.setSortType(false);
  957.             sqlQueryObject.setANDLogicOperator(true);
  958.             String query = sqlQueryObject.createSQLQuery();
  959.             stm=con.prepareStatement(query);
  960.             stm.setString(1, idAccordo.getNome());
  961.             
  962.             long idSoggettoReferente =  0;
  963.             if(idAccordo.getSoggettoReferente()!=null){
  964.                 idSoggettoReferente = DBUtils.getIdSoggetto(idAccordo.getSoggettoReferente().getNome(), idAccordo.getSoggettoReferente().getTipo(), con, tipoDB);
  965.                 if(idSoggettoReferente<=0){
  966.                     throw new CoreException("[getIdAccordoServizioParteComune] Soggetto Referente ["+idAccordo.getSoggettoReferente().toString()+"] non esiste");
  967.                 }
  968.             }
  969.             stm.setLong(2, idSoggettoReferente);
  970.                 
  971.             rs=stm.executeQuery();

  973.             if(rs.next()){
  974.                 int versione = rs.getInt("versione");
  975.                 if(versione>0) {
  976.                     return versione+1;
  977.                 }
  978.             }

  980.             return 1; // accordo non esistente

  982.         }catch (Exception e) {
  983.             throw new CoreException(e);
  984.         }finally
  985.         {
  986.             //Chiudo statement and resultset
  987.             JDBCUtilities.closeResources(rs, stm);

  989.         }
  990.     }
  991.     
  992.     
  993.     
  994.     
  995.     public static long getIdAccordoCooperazione(IDAccordoCooperazione idAccordo,Connection con, String tipoDB) throws CoreException{
  996.         PreparedStatement stm = null;
  997.         ResultSet rs = null;
  998.         long idAccordoLong=-1;
  999.         try
  1000.         {
  1001.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1002.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_COOPERAZIONE);
  1003.             sqlQueryObject.addSelectField("*");
  1004.             sqlQueryObject.addWhereCondition("nome = ?");
  1005.             sqlQueryObject.addWhereCondition("id_referente = ?");
  1006.             sqlQueryObject.addWhereCondition("versione = ?");
  1007.             sqlQueryObject.setANDLogicOperator(true);
  1008.             String query = sqlQueryObject.createSQLQuery();
  1009.             stm=con.prepareStatement(query);
  1010.             stm.setString(1, idAccordo.getNome());
  1011.                 
  1012.             long idSoggettoReferente =  0;
  1013.             if(idAccordo.getSoggettoReferente()!=null){
  1014.                 idSoggettoReferente = DBUtils.getIdSoggetto(idAccordo.getSoggettoReferente().getNome(), idAccordo.getSoggettoReferente().getTipo(), con, tipoDB);
  1015.                 if(idSoggettoReferente<=0){
  1016.                     throw new CoreException("[getIdAccordoCooperazione] Soggetto Referente ["+idAccordo.getSoggettoReferente().toString()+"] non esiste");
  1017.                 }
  1018.             }
  1019.             stm.setLong(2, idSoggettoReferente);
  1020.                 
  1021.             stm.setInt(3, idAccordo.getVersione());
  1022.                         
  1023.             rs=stm.executeQuery();

  1025.             if(rs.next()){
  1026.                 idAccordoLong = rs.getLong("id");
  1027.             }

  1029.             return idAccordoLong;

  1031.         }catch (Exception e) {
  1032.             throw new CoreException(e);
  1033.         }finally
  1034.         {
  1035.             //Chiudo statement and resultset
  1036.             JDBCUtilities.closeResources(rs, stm);

  1038.         }
  1039.     }
  1040.     
  1041.     
  1042.     public static long getIdAccordoServizioParteSpecifica(IDServizio idServizio,Connection con, String tipoDB) throws CoreException{
  1043.         PreparedStatement stm = null;
  1044.         ResultSet rs = null;
  1045.         long idAccordoLong=-1;
  1046.         try
  1047.         {
  1048.             
  1049.             // NOTA: nell'APS, il soggetto e la versione sono obbligatori
  1050.             
  1051.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1052.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1053.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1054.             sqlQueryObject.addSelectField("*");
  1055.             sqlQueryObject.setANDLogicOperator(true);
  1056.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  1057.             sqlQueryObject.addWhereCondition("tipo_soggetto = ?");
  1058.             sqlQueryObject.addWhereCondition("nome_soggetto = ?");
  1059.             sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  1060.             sqlQueryObject.addWhereCondition("nome_servizio = ?");
  1061.             sqlQueryObject.addWhereCondition("versione_servizio = ?");
  1062.             String query = sqlQueryObject.createSQLQuery();
  1063.             stm=con.prepareStatement(query);
  1064.             stm.setString(1, idServizio.getSoggettoErogatore().getTipo());
  1065.             stm.setString(2, idServizio.getSoggettoErogatore().getNome());
  1066.             stm.setString(3, idServizio.getTipo());
  1067.             stm.setString(4, idServizio.getNome());
  1068.             stm.setInt(5, idServizio.getVersione());
  1069.             
  1070.             rs=stm.executeQuery();

  1072.             if(rs.next()){
  1073.                 idAccordoLong = rs.getLong("id");
  1074.             }

  1076.             return idAccordoLong;

  1078.         }catch (Exception e) {
  1079.             throw new CoreException(e);
  1080.         }finally
  1081.         {
  1082.             //Chiudo statement and resultset
  1083.             JDBCUtilities.closeResources(rs, stm);

  1085.         }
  1086.     }
  1087.     
  1088.     
  1089.     public static long getIdFruizioneServizio(IDServizio idServizio,IDSoggetto idFruitore, Connection con, String tipoDB) throws CoreException{
  1090.         return getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, CostantiDB.SOGGETTI);
  1091.     }
  1092.     public static long getIdFruizioneServizio(IDServizio idServizio,IDSoggetto idFruitore, Connection con, String tipoDB, String tabellaSoggetti) throws CoreException{
  1093.         return _getIdFruizioneServizio(DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB), idFruitore, con, tipoDB, tabellaSoggetti);
  1094.     }
  1095.     
  1096.     private static long _getIdFruizioneServizio(long idServizio,IDSoggetto idFruitore, Connection con, String tipoDB, String tabellaSoggetti) throws CoreException{
  1097.         PreparedStatement stm = null;
  1098.         ResultSet rs = null;
  1099.         long idFruizione=-1;
  1100.         try
  1101.         {
  1102.             
  1103.             // NOTA: nell'APS, il soggetto e la versione sono obbligatori
  1104.             
  1105.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1106.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  1107.             sqlQueryObject.addSelectField("id");
  1108.             sqlQueryObject.setANDLogicOperator(true);
  1109.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_servizio = ?");
  1110.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_soggetto = ?");
  1111.             String query = sqlQueryObject.createSQLQuery();
  1112.             stm=con.prepareStatement(query);
  1113.             stm.setLong(1, idServizio);
  1114.             stm.setLong(2, DBUtils.getIdSoggetto(idFruitore.getNome(), idFruitore.getTipo(), con, tipoDB,tabellaSoggetti));
  1115.             
  1116.             rs=stm.executeQuery();

  1118.             if(rs.next()){
  1119.                 idFruizione = rs.getLong("id");
  1120.             }

  1122.             return idFruizione;

  1124.         }catch (Exception e) {
  1125.             throw new CoreException(e);
  1126.         }finally
  1127.         {
  1128.             //Chiudo statement and resultset
  1129.             JDBCUtilities.closeResources(rs, stm);

  1131.         }
  1132.     }
  1133.     

  1135.     public static long getIdDocumento(String nome, String tipo, String ruolo, long idProprietario,Connection con,String tipoDB,String tipoProprietario) throws CoreException{
  1136.         PreparedStatement stm = null;
  1137.         ResultSet rs = null;
  1138.         long idDoc=-1;
  1139.         try
  1140.         {
  1141.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1142.             sqlQueryObject.addFromTable(CostantiDB.DOCUMENTI);
  1143.             sqlQueryObject.addSelectField("id");
  1144.             sqlQueryObject.addWhereCondition("id_proprietario = ?");
  1145.             sqlQueryObject.addWhereCondition("nome = ?");
  1146.             if(tipo!=null) {
  1147.                 sqlQueryObject.addWhereCondition("tipo = ?");
  1148.             }
  1149.             if(ruolo!=null) {
  1150.                 sqlQueryObject.addWhereCondition("ruolo = ?");
  1151.             }
  1152.             sqlQueryObject.addWhereCondition("tipo_proprietario = ?");
  1153.             sqlQueryObject.setANDLogicOperator(true);
  1154.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1155.             stm = con.prepareStatement(sqlQuery);
  1156.             int index = 1;
  1157.             stm.setLong(index++, idProprietario);
  1158.             stm.setString(index++, nome);
  1159.             if(tipo!=null) {
  1160.                 stm.setString(index++, tipo);
  1161.             }
  1162.             if(ruolo!=null) {
  1163.                 stm.setString(index++, ruolo);
  1164.             }
  1165.             stm.setString(index++, tipoProprietario);
  1166.             rs = stm.executeQuery();
  1167.             if (rs.next())
  1168.                 idDoc = rs.getLong("id");
  1169.             rs.close();
  1170.             stm.close();

  1172.             return idDoc;
  1173.         }catch (Exception e) {
  1174.             throw new CoreException(e);
  1175.         }finally
  1176.         {
  1177.             //Chiudo statement and resultset
  1178.             JDBCUtilities.closeResources(rs, stm);

  1180.         }
  1181.     }
  1182.     
  1183.     
  1184.     public static long getIdProtocolProperty(String tipoProprietario, long idProprietario,String nome, Connection con,String tipoDB) throws CoreException{
  1185.         PreparedStatement stm = null;
  1186.         ResultSet rs = null;
  1187.         long idPP=-1;
  1188.         try
  1189.         {
  1190.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1191.             sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  1192.             sqlQueryObject.addSelectField("id");
  1193.             sqlQueryObject.addWhereCondition("tipo_proprietario = ?");
  1194.             sqlQueryObject.addWhereCondition("id_proprietario = ?");
  1195.             sqlQueryObject.addWhereCondition("name = ?");
  1196.             sqlQueryObject.setANDLogicOperator(true);
  1197.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1198.             stm = con.prepareStatement(sqlQuery);
  1199.             stm.setString(1, tipoProprietario);
  1200.             stm.setLong(2, idProprietario);
  1201.             stm.setString(3, nome);
  1202.             rs = stm.executeQuery();
  1203.             if (rs.next())
  1204.                 idPP = rs.getLong("id");
  1205.             rs.close();
  1206.             stm.close();

  1208.             return idPP;
  1209.         }catch (Exception e) {
  1210.             throw new CoreException(e);
  1211.         }finally
  1212.         {
  1213.             //Chiudo statement and resultset
  1214.             JDBCUtilities.closeResources(rs, stm);

  1216.         }
  1217.     }
  1218.     
  1219.     
  1220.     
  1221.     
  1222.     
  1223.     public static long getIdRegistroPlugin(String nome, Connection con,String tipoDB) throws CoreException{
  1224.         PreparedStatement stm = null;
  1225.         ResultSet rs = null;
  1226.         long idRP=-1;
  1227.         try
  1228.         {
  1229.             if(nome==null) {
  1230.                 throw new CoreException("Nome non fornito");
  1231.             }
  1232.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1233.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  1234.             sqlQueryObject.addSelectField("id");
  1235.             sqlQueryObject.addWhereCondition("nome=?");
  1236.             sqlQueryObject.setANDLogicOperator(true);
  1237.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1238.             stm = con.prepareStatement(sqlQuery);
  1239.             stm.setString(1, nome);
  1240.             rs = stm.executeQuery();
  1241.             if(rs.next()) {
  1242.                 idRP = rs.getLong("id");
  1243.             }
  1244.             rs.close();
  1245.             stm.close();
  1246.             rs=null;
  1247.             stm=null;
  1248.             
  1249.             return idRP;
  1250.         }catch (Exception e) {
  1251.             throw new CoreException(e);
  1252.         }finally
  1253.         {
  1254.             //Chiudo statement and resultset
  1255.             JDBCUtilities.closeResources(rs, stm);

  1257.         }
  1258.     }
  1259.     
  1260.     
  1261.     public static long getIdPlugin(String className, String label, String tipoPlugin, String tipo, Connection con,String tipoDB) throws CoreException{
  1262.         PreparedStatement stm = null;
  1263.         ResultSet rs = null;
  1264.         long idRP=-1;
  1265.         try
  1266.         {
  1267.             if(className==null) {
  1268.                 throw new CoreException("ClassName non fornito");
  1269.             }
  1270.             if(label==null) {
  1271.                 throw new CoreException("Label non fornito");
  1272.             }
  1273.             if(tipoPlugin==null) {
  1274.                 throw new CoreException("TipoPlugin non fornito");
  1275.             }
  1276.             if(tipo==null) {
  1277.                 throw new CoreException("Tipo non fornito");
  1278.             }
  1279.             
  1280.             
  1281.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1282.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_CLASSI);
  1283.             sqlQueryObject.addSelectField("id");
  1284.             sqlQueryObject.addWhereCondition("class_name=?");
  1285.             sqlQueryObject.addWhereCondition("label=?");
  1286.             sqlQueryObject.addWhereCondition("tipo_plugin=?");
  1287.             sqlQueryObject.addWhereCondition("tipo=?");
  1288.             sqlQueryObject.setANDLogicOperator(true);
  1289.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1290.             stm = con.prepareStatement(sqlQuery);
  1291.             stm.setString(1, className);
  1292.             stm.setString(2, label);
  1293.             stm.setString(3, tipoPlugin);
  1294.             stm.setString(4, tipo);
  1295.             rs = stm.executeQuery();
  1296.             if(rs.next()) {
  1297.                 idRP = rs.getLong("id");
  1298.             }
  1299.             rs.close();
  1300.             stm.close();
  1301.             rs=null;
  1302.             stm=null;
  1303.             
  1304.             return idRP;
  1305.         }catch (Exception e) {
  1306.             throw new CoreException(e);
  1307.         }finally
  1308.         {
  1309.             //Chiudo statement and resultset
  1310.             JDBCUtilities.closeResources(rs, stm);

  1312.         }
  1313.     }
  1314.     
  1315.     
  1316.     public static long getUrlInvocazioneRegola(String nome, Connection con,String tipoDB) throws CoreException{
  1317.         PreparedStatement stm = null;
  1318.         ResultSet rs = null;
  1319.         long idRP=-1;
  1320.         try
  1321.         {
  1322.             if(nome==null) {
  1323.                 throw new CoreException("Nome non fornito");
  1324.             }
  1325.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1326.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  1327.             sqlQueryObject.addSelectField("id");
  1328.             sqlQueryObject.addWhereCondition("nome=?");
  1329.             sqlQueryObject.setANDLogicOperator(true);
  1330.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1331.             stm = con.prepareStatement(sqlQuery);
  1332.             stm.setString(1, nome);
  1333.             rs = stm.executeQuery();
  1334.             if(rs.next()) {
  1335.                 idRP = rs.getLong("id");
  1336.             }
  1337.             rs.close();
  1338.             stm.close();
  1339.             rs=null;
  1340.             stm=null;
  1341.             
  1342.             return idRP;
  1343.         }catch (Exception e) {
  1344.             throw new CoreException(e);
  1345.         }finally
  1346.         {
  1347.             //Chiudo statement and resultset
  1348.             JDBCUtilities.closeResources(rs, stm);

  1350.         }
  1351.     }
  1352.     
  1353.     

  1355.     public static void setPropertiesForSearch(ISQLQueryObject sqlQueryObject, Map<String, String> properties, String tabellaPadre, 
  1356.             String tabellaProprieta, String columnName, String columnValue, String columnFK) throws SQLQueryObjectException{
  1357.         if(properties!=null && properties.size()>0){
  1358.             String [] conditions = new String[properties.size()];
  1359.             int i = 0;
  1360.             for (String nome : properties.keySet()) {

  1362.                 String aliasTabella = "pp"+i+tabellaPadre;
  1363.                 sqlQueryObject.addFromTable(tabellaProprieta, aliasTabella);
  1364.                 sqlQueryObject.setANDLogicOperator(true);
  1365.                 sqlQueryObject.addWhereCondition(aliasTabella+"."+columnFK+"="+tabellaPadre+".id");
  1366.                 String valore = properties.get(nome);
  1367.                                 
  1368.                 if(conditions[i]!=null){
  1369.                     conditions[i] = conditions[i] + " AND ";
  1370.                 }
  1371.                 else {
  1372.                     conditions[i] = "";
  1373.                 }
  1374.                 conditions[i] = conditions[i] + " " + aliasTabella+"."+columnName+"=?";
  1375.                 
  1376.                 if(valore!=null){
  1377.                     if(conditions[i]!=null){
  1378.                         conditions[i] = conditions[i] + " AND ";
  1379.                     }
  1380.                     else {
  1381.                         conditions[i] = "";
  1382.                     }
  1383.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+columnValue+"=?";
  1384.                 }
  1385.                 else {
  1386.                     if(conditions[i]!=null){
  1387.                         conditions[i] = conditions[i] + " AND ";
  1388.                     }
  1389.                     else {
  1390.                         conditions[i] = "";
  1391.                     }
  1392.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+columnValue+" is null";
  1393.                 }
  1394.                 
  1395.                 // casoSpecialeValoreNull
  1396.                 ISQLQueryObject sqlQueryObjectPropertyNotExists = null;
  1397.                 // in un caso dove il valore non e' definito nel database ci possono essere due casistiche:
  1398.                 // 1) Passando via govwayConsole, la proprieta' esiste con il nome ('name') ed e' valorizzata null in tutte le colonne (value_string,value_number,value_boolean)
  1399.                 // 2) Passando via govwayLoader, in una configurazione xml, non si definisce la proprietà senza il valore, quindi la riga con il nome non esistera proprio nel db.
  1400.                 if(valore==null){
  1401.                     
  1402.                     ISQLQueryObject sqlQueryObjectPropertyNotExistsInternal = sqlQueryObject.newSQLQueryObject();
  1403.                     String aliasTabellaNotExists =  "not_exists_"+aliasTabella;
  1404.                     sqlQueryObjectPropertyNotExistsInternal.addFromTable(tabellaProprieta, aliasTabellaNotExists);
  1405.                     sqlQueryObjectPropertyNotExistsInternal.addSelectField(aliasTabellaNotExists, "id");
  1406.                     sqlQueryObjectPropertyNotExistsInternal.addWhereCondition(aliasTabellaNotExists+"."+columnFK+"="+aliasTabella+"."+columnFK);
  1407.                     sqlQueryObjectPropertyNotExistsInternal.addWhereCondition(aliasTabellaNotExists+"."+columnName+"=?");
  1408.                     sqlQueryObjectPropertyNotExistsInternal.setANDLogicOperator(true);
  1409.                     
  1410.                     sqlQueryObjectPropertyNotExists = sqlQueryObject.newSQLQueryObject();
  1411.                     sqlQueryObjectPropertyNotExists.addWhereExistsCondition(true, sqlQueryObjectPropertyNotExistsInternal);

  1413.                     conditions[i] = "( " + conditions[i] + " ) OR ( " + sqlQueryObjectPropertyNotExists.createSQLConditions() + " )";
  1414.                 }
  1415.                 i++;
  1416.             }
  1417.             sqlQueryObject.addWhereCondition(true, conditions);
  1418.         }
  1419.     }
  1420.     
  1421.     public static void setPropertiesForSearch(PreparedStatement stmt, int index, 
  1422.             Map<String, String> properties,
  1423.             String tipoDatabase, Logger log) throws SQLQueryObjectException, SQLException, JDBCAdapterException, UtilsException{
  1424.         
  1425.         GenericJDBCParameterUtilities jdbcParameterUtilities = new GenericJDBCParameterUtilities(TipiDatabase.toEnumConstant(tipoDatabase));
  1426.         
  1427.         if(properties!=null && properties.size()>0){
  1428.             int i = 0;
  1429.             for (String nome : properties.keySet()) {
  1430.                 
  1431.                 String valore = properties.get(nome);
  1432.                 
  1433.                 log.debug("Proprieta["+i+"] nome stmt.setString("+nome+")");
  1434.                 stmt.setString(index++, nome);
  1435.                                 
  1436.                 if(valore!=null){
  1437.                     log.debug("Proprieta["+i+"] valore stmt.setString("+valore+")");
  1438.                     jdbcParameterUtilities.setParameter(stmt, index++, valore, String.class);
  1439.                 }
  1440.                 
  1441.                 // casoSpecialeValoreNull
  1442.                 // in un caso dove il valore non e' definito nel database ci possono essere due casistiche:
  1443.                 // 1) Passando via govwayConsole, la proprieta' esiste con il nome ('name') ed e' valorizzata null in tutte le colonne (value_string,value_number,value_boolean)
  1444.                 // 2) Passando via govwayLoader, in una configurazione xml, non si definisce la proprietà senza il valore, quindi la riga con il nome non esistera proprio nel db.
  1445.                 if(valore==null){
  1446.                     log.debug("Proprieta["+i+"] nome stmt.setString("+nome+")");
  1447.                     stmt.setString(index++, nome);
  1448.                 }
  1449.                 
  1450.                 i++;
  1451.             }
  1452.         }
  1453.     }


  1456.     public static void setFiltriConnettoreApplicativo(ISQLQueryObject sqlQueryObject, String tipoDB,
  1457.             TipiConnettore tipoConnettore, String endpointType, boolean tipoConnettoreIntegrationManager,
  1458.             String filtroConnettoreTokenPolicy, String filtroConnettoreEndpoint, String filtroConnettoreKeystore, String filtroConnettoreDebug) throws Exception {

  1460.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1461.         sql.addFromTable(CostantiDB.CONNETTORI);
  1462.         sql.setANDLogicOperator(true);
  1463.         sql.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_connettore_inv="+CostantiDB.CONNETTORI+".id");
  1464.         setFiltriConnettore(sql, tipoDB,
  1465.                 tipoConnettore, endpointType, tipoConnettoreIntegrationManager,
  1466.                 filtroConnettoreTokenPolicy, filtroConnettoreEndpoint, filtroConnettoreKeystore, filtroConnettoreDebug,
  1467.                 CostantiDB.SERVIZI_APPLICATIVI);
  1468.         sqlQueryObject.addWhereExistsCondition(false, sql);
  1469.         
  1470.     }
  1471.     public static void setFiltriConnettoreErogazione(ISQLQueryObject sqlQueryObject, String tipoDB,
  1472.             TipiConnettore tipoConnettore, String endpointType, boolean tipoConnettoreIntegrationManager,
  1473.             String filtroConnettoreTokenPolicy, String filtroConnettoreEndpoint, String filtroConnettoreKeystore, String filtroConnettoreDebug) throws Exception {

  1475.         String aliasMAPPING_EROGAZIONE_PA = "c_map";
  1476.         String aliasPORTE_APPLICATIVE = "c_pa";
  1477.         String aliasPORTE_APPLICATIVE_SA = "c_pasa";
  1478.         String aliasSERVIZI_APPLICATIVI = "c_sa";
  1479.         
  1480.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1481.         sql.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA, aliasMAPPING_EROGAZIONE_PA);
  1482.         sql.addFromTable(CostantiDB.PORTE_APPLICATIVE, aliasPORTE_APPLICATIVE);
  1483.         sql.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA, aliasPORTE_APPLICATIVE_SA);
  1484.         sql.addFromTable(CostantiDB.SERVIZI_APPLICATIVI, aliasSERVIZI_APPLICATIVI);
  1485.         sql.addFromTable(CostantiDB.CONNETTORI);
  1486.         sql.setANDLogicOperator(true);
  1487.         sql.addWhereCondition(aliasMAPPING_EROGAZIONE_PA+".id_erogazione="+CostantiDB.SERVIZI+".id");
  1488.         sql.addWhereCondition(aliasMAPPING_EROGAZIONE_PA+".id_porta="+aliasPORTE_APPLICATIVE+".id");
  1489.         sql.addWhereCondition(aliasPORTE_APPLICATIVE_SA+".id_porta="+aliasPORTE_APPLICATIVE+".id");
  1490.         sql.addWhereCondition(aliasPORTE_APPLICATIVE_SA+".id_servizio_applicativo="+aliasSERVIZI_APPLICATIVI+".id");
  1491.         sql.addWhereCondition(aliasSERVIZI_APPLICATIVI+".id_connettore_inv="+CostantiDB.CONNETTORI+".id");
  1492.         setFiltriConnettore(sql, tipoDB,
  1493.                 tipoConnettore, endpointType, tipoConnettoreIntegrationManager,
  1494.                 filtroConnettoreTokenPolicy, filtroConnettoreEndpoint, filtroConnettoreKeystore, filtroConnettoreDebug,
  1495.                 aliasSERVIZI_APPLICATIVI);
  1496.         sqlQueryObject.addWhereExistsCondition(false, sql);
  1497.         
  1498.     }
  1499.     public static void setFiltriConnettoreFruizione(ISQLQueryObject sqlQueryObject, String tipoDB,
  1500.             TipiConnettore tipoConnettore, String endpointType, boolean tipoConnettoreIntegrationManager,
  1501.             String filtroConnettoreTokenPolicy, String filtroConnettoreEndpoint, String filtroConnettoreKeystore, String filtroConnettoreDebug) throws Exception {
  1502.         
  1503.         ISQLQueryObject sqlConnettoreDefault = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1504.         sqlConnettoreDefault.addFromTable(CostantiDB.CONNETTORI);
  1505.         sqlConnettoreDefault.setANDLogicOperator(true);
  1506.         sqlConnettoreDefault.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_connettore="+CostantiDB.CONNETTORI+".id");
  1507.         setFiltriConnettore(sqlConnettoreDefault, tipoDB,
  1508.                 tipoConnettore, endpointType, false,
  1509.                 filtroConnettoreTokenPolicy, filtroConnettoreEndpoint, filtroConnettoreKeystore, filtroConnettoreDebug,
  1510.                 null);
  1511.         
  1512.         ISQLQueryObject sqlGruppiConnettoreRidefinito = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1513.         sqlGruppiConnettoreRidefinito.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  1514.         sqlGruppiConnettoreRidefinito.addFromTable(CostantiDB.CONNETTORI);
  1515.         sqlGruppiConnettoreRidefinito.setANDLogicOperator(true);
  1516.         sqlGruppiConnettoreRidefinito.addWhereCondition(CostantiDB.SERVIZI_FRUITORI_AZIONI+".id_fruizione="+CostantiDB.SERVIZI_FRUITORI+".id");
  1517.         sqlGruppiConnettoreRidefinito.addWhereCondition(CostantiDB.SERVIZI_FRUITORI_AZIONI+".id_connettore="+CostantiDB.CONNETTORI+".id");
  1518.         setFiltriConnettore(sqlGruppiConnettoreRidefinito, tipoDB,
  1519.                 tipoConnettore, endpointType, false,
  1520.                 filtroConnettoreTokenPolicy, filtroConnettoreEndpoint, filtroConnettoreKeystore, filtroConnettoreDebug,
  1521.                 null);
  1522.         
  1523.         sqlQueryObject.addWhereCondition(false, 
  1524.                 sqlConnettoreDefault.getWhereExistsCondition(false, sqlConnettoreDefault),
  1525.                 sqlConnettoreDefault.getWhereExistsCondition(false, sqlGruppiConnettoreRidefinito));
  1526.         
  1527.     }
  1528.     private static void setFiltriConnettore(ISQLQueryObject sqlQueryObject, String tipoDB,
  1529.             TipiConnettore tipoConnettore, String endpointType, boolean tipoConnettoreIntegrationManager,
  1530.             String filtroConnettoreTokenPolicy, String filtroConnettoreEndpoint, String filtroConnettoreKeystore, String filtroConnettoreDebug,
  1531.             String aliasTabellaServiziApplicativi) throws Exception {
  1532.         
  1533.         // NOTA: logica inserita anche in PorteApplicativeHelper.applicaFiltriRicercaConnettoriMultipli
  1534.         
  1535.         boolean setEndpointtype = false;
  1536.         
  1537.         if(endpointType!=null) {
  1538.             sqlQueryObject.addWhereLikeCondition(CostantiDB.CONNETTORI+".endpointtype", endpointType, false, false, false);
  1539.             setEndpointtype=true;
  1540.         }
  1541.         else if(tipoConnettore!=null) {
  1542.             if(TipiConnettore.CUSTOM.equals(tipoConnettore)) {
  1543.                 List<String> tipiConosciuti = new ArrayList<>();
  1544.                 TipiConnettore[] tipi = TipiConnettore.values();
  1545.                 for (TipiConnettore tipiConnettore : tipi) {
  1546.                     tipiConosciuti.add(tipiConnettore.getNome());
  1547.                 }
  1548.                 ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1549.                 sql.addFromTable(CostantiDB.CONNETTORI);
  1550.                 sql.setANDLogicOperator(true);
  1551.                 sql.setNOTBeforeConditions(true);
  1552.                 sql.addWhereINCondition(CostantiDB.CONNETTORI+".endpointtype", true, tipiConosciuti.toArray(new String[1]));
  1553.                 setEndpointtype=true;
  1554.                 sqlQueryObject.addWhereCondition(sql.createSQLConditions());
  1555.             }
  1556.         }
  1557.         
  1558.         if(tipoConnettoreIntegrationManager) {
  1559.             sqlQueryObject.addWhereLikeCondition(aliasTabellaServiziApplicativi+".getmsginv", CostantiDB.STATO_FUNZIONALITA_ABILITATO, false, false, false);
  1560.         }
  1561.         
  1562.         if(filtroConnettoreTokenPolicy!=null) {
  1563.             sqlQueryObject.addWhereLikeCondition(CostantiDB.CONNETTORI+".token_policy", filtroConnettoreTokenPolicy, false, false, false);
  1564.         }
  1565.         
  1566.         if(filtroConnettoreEndpoint!=null) {
  1567.             List<String> query = new ArrayList<>();
  1568.             if((tipoConnettore==null || TipiConnettore.HTTP.equals(tipoConnettore))) {
  1569.                 query.add(sqlQueryObject.getWhereLikeCondition(CostantiDB.CONNETTORI+".url", filtroConnettoreEndpoint, LikeConfig.contains(true)));
  1570.             }
  1571.             if((tipoConnettore==null || TipiConnettore.HTTPS.equals(tipoConnettore))) {
  1572.                 ISQLQueryObject exists = buildSQLQueryObjectConnettoreCustomPropertyContains(tipoDB, CostantiDB.CONNETTORE_HTTP_LOCATION, filtroConnettoreEndpoint);
  1573.                 query.add(sqlQueryObject.getWhereExistsCondition(false, exists));
  1574.             }
  1575.             //if((tipoConnettore==null || TipiConnettore.FILE.equals(tipoConnettore))) {
  1576.             if(tipoConnettore!=null && TipiConnettore.FILE.equals(tipoConnettore)) {
  1577.                 ISQLQueryObject existsRequest = buildSQLQueryObjectConnettoreCustomPropertyContains(tipoDB, CostantiDB.CONNETTORE_FILE_REQUEST_OUTPUT_FILE, filtroConnettoreEndpoint);
  1578.                 query.add(sqlQueryObject.getWhereExistsCondition(false, existsRequest));
  1579.                 ISQLQueryObject existsRequestHeader = buildSQLQueryObjectConnettoreCustomPropertyContains(tipoDB, CostantiDB.CONNETTORE_FILE_REQUEST_OUTPUT_FILE_HEADERS, filtroConnettoreEndpoint);
  1580.                 query.add(sqlQueryObject.getWhereExistsCondition(false, existsRequestHeader));
  1581.                 ISQLQueryObject existsResponse = buildSQLQueryObjectConnettoreCustomPropertyContains(tipoDB, CostantiDB.CONNETTORE_FILE_RESPONSE_INPUT_FILE, filtroConnettoreEndpoint);
  1582.                 query.add(sqlQueryObject.getWhereExistsCondition(false, existsResponse));
  1583.                 ISQLQueryObject existsResponseHeader = buildSQLQueryObjectConnettoreCustomPropertyContains(tipoDB, CostantiDB.CONNETTORE_FILE_RESPONSE_INPUT_FILE_HEADERS, filtroConnettoreEndpoint);
  1584.                 query.add(sqlQueryObject.getWhereExistsCondition(false, existsResponseHeader));
  1585.             }
  1586.             //if((tipoConnettore==null || TipiConnettore.JMS.equals(tipoConnettore))) {
  1587.             if(tipoConnettore!=null && TipiConnettore.JMS.equals(tipoConnettore)) {
  1588.                 query.add(sqlQueryObject.getWhereLikeCondition(CostantiDB.CONNETTORI+".nome", filtroConnettoreEndpoint, LikeConfig.contains(true)));
  1589.                 query.add(sqlQueryObject.getWhereLikeCondition(CostantiDB.CONNETTORI+".provurl", filtroConnettoreEndpoint, LikeConfig.contains(true)));
  1590.                 query.add(sqlQueryObject.getWhereLikeCondition(CostantiDB.CONNETTORI+".connection_factory", filtroConnettoreEndpoint, LikeConfig.contains(true)));
  1591.                 query.add(sqlQueryObject.getWhereLikeCondition(CostantiDB.CONNETTORI+".initcont", filtroConnettoreEndpoint, LikeConfig.contains(true)));
  1592.                 query.add(sqlQueryObject.getWhereLikeCondition(CostantiDB.CONNETTORI+".urlpkg", filtroConnettoreEndpoint, LikeConfig.contains(true)));
  1593.             }
  1594.             if(!query.isEmpty()) {
  1595.                 sqlQueryObject.addWhereCondition(false, query.toArray(new String[1]));
  1596.                 if(!setEndpointtype) {
  1597.                     sqlQueryObject.addWhereCondition(CostantiDB.CONNETTORI+".endpointtype <> '"+TipiConnettore.DISABILITATO.getNome()+"'");
  1598.                 }
  1599.             }
  1600.         }
  1601.         
  1602.         if(filtroConnettoreKeystore!=null &&
  1603.                 (tipoConnettore==null || TipiConnettore.HTTPS.equals(tipoConnettore))
  1604.                 ) {
  1605.             ISQLQueryObject existsKeystore = buildSQLQueryObjectConnettoreCustomPropertyContains(tipoDB, CostantiDB.CONNETTORE_HTTPS_KEY_STORE_LOCATION, filtroConnettoreKeystore);
  1606.             ISQLQueryObject existsTruststore = buildSQLQueryObjectConnettoreCustomPropertyContains(tipoDB, CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_LOCATION, filtroConnettoreKeystore);
  1607.             sqlQueryObject.addWhereCondition(false,
  1608.                     sqlQueryObject.getWhereExistsCondition(false, existsKeystore),
  1609.                     sqlQueryObject.getWhereExistsCondition(false, existsTruststore)
  1610.                     );
  1611.         }
  1612.         
  1613.         if(filtroConnettoreDebug!=null) {
  1614.             if(Filtri.FILTRO_CONNETTORE_DEBUG_VALORE_ABILITATO.equals(filtroConnettoreDebug)) {
  1615.                 sqlQueryObject.addWhereCondition(CostantiDB.CONNETTORI+".debug="+CostantiDB.TRUE);
  1616.             }
  1617.             else if(Filtri.FILTRO_CONNETTORE_DEBUG_VALORE_DISABILITATO.equals(filtroConnettoreDebug)) {
  1618.                 sqlQueryObject.addWhereCondition(CostantiDB.CONNETTORI+".debug="+CostantiDB.FALSE);
  1619.             }
  1620.         }
  1621.         
  1622.     } 
  1623.     private static ISQLQueryObject buildSQLQueryObjectConnettoreCustomPropertyContains(String tipoDB, String nomeProprieta, String valoreProprieta) throws Exception {
  1624.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1625.         sql.addFromTable(CostantiDB.CONNETTORI_CUSTOM);
  1626.         sql.setANDLogicOperator(true);
  1627.         sql.addWhereCondition(CostantiDB.CONNETTORI_CUSTOM+".id_connettore="+CostantiDB.CONNETTORI+".id");
  1628.         sql.addWhereLikeCondition(CostantiDB.CONNETTORI_CUSTOM+".name", nomeProprieta, false, false, false);
  1629.         sql.addWhereLikeCondition(CostantiDB.CONNETTORI_CUSTOM+".value", valoreProprieta, LikeConfig.contains(true));
  1630.         return sql;
  1631.     }
  1632.     
  1633.     
  1634.     
  1635.     
  1636.     public static void setFiltriModIApplicativi(ISQLQueryObject sqlQueryObject, String tipoDB,
  1637.             Boolean filtroModISicurezzaMessaggio,
  1638.             String filtroModIKeystorePath, String filtroModIKeystoreSubject, String filtroModIKeystoreIssuer, 
  1639.             Boolean filtroModISicurezzaToken,
  1640.             String filtroModITokenPolicy, String filtroModITokenClientId,
  1641.             String filtroModIAudience,
  1642.             boolean checkCredenzialiBase) throws Exception {
  1643.         
  1644.         ProprietariProtocolProperty proprietario = ProprietariProtocolProperty.SERVIZIO_APPLICATIVO;
  1645.         String tabellaDB =  CostantiDB.SERVIZI_APPLICATIVI ;
  1646.         
  1647.         List<ISQLQueryObject> listSqlQueryProtocolProperties = new ArrayList<>();
  1648.         
  1649.         if(filtroModISicurezzaMessaggio!=null) {
  1650.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1651.                     tipoDB, CostantiDB.MODIPA_SICUREZZA_MESSAGGIO , null, null, filtroModISicurezzaMessaggio);
  1652.             listSqlQueryProtocolProperties.add(sql);
  1653.         }
  1654.         
  1655.         if(filtroModIKeystorePath!=null) {
  1656.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1657.                     tipoDB, CostantiDB.MODIPA_KEYSTORE_PATH, null, filtroModIKeystorePath, null);
  1658.             listSqlQueryProtocolProperties.add(sql);
  1659.         }
  1660.         
  1661.         if(filtroModIKeystoreSubject!=null) {
  1662.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1663.                     tipoDB, CostantiDB.MODIPA_KEY_CN_SUBJECT, null, filtroModIKeystoreSubject, null);
  1664.             listSqlQueryProtocolProperties.add(sql);
  1665.         }
  1666.         
  1667.         if(filtroModIKeystoreIssuer!=null) {
  1668.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1669.                     tipoDB, CostantiDB.MODIPA_KEY_CN_ISSUER, null, filtroModIKeystoreIssuer, null);
  1670.             listSqlQueryProtocolProperties.add(sql);
  1671.         }
  1672.         
  1673.         if(filtroModISicurezzaToken!=null) {
  1674.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1675.                     tipoDB, CostantiDB.MODIPA_SICUREZZA_TOKEN , null, null, filtroModISicurezzaToken);
  1676.             listSqlQueryProtocolProperties.add(sql);
  1677.         }
  1678.         
  1679.         if(filtroModITokenPolicy!=null) {
  1680.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1681.                     tipoDB, CostantiDB.MODIPA_SICUREZZA_TOKEN_POLICY, null, filtroModITokenPolicy, null);
  1682.             listSqlQueryProtocolProperties.add(sql);            
  1683.         }
  1684.         
  1685.         if(filtroModITokenClientId!=null) {
  1686.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1687.                     tipoDB, CostantiDB.MODIPA_SICUREZZA_TOKEN_CLIENT_ID, null, filtroModITokenClientId, null);
  1688.             listSqlQueryProtocolProperties.add(sql);
  1689.         }
  1690.         
  1691.         if(filtroModIAudience!=null) {
  1692.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1693.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_RISPOSTA_AUDIENCE , null, filtroModIAudience, null);
  1694.             listSqlQueryProtocolProperties.add(sql);
  1695.         }
  1696.         
  1697.         
  1698.         
  1699.         if(checkCredenzialiBase && 
  1700.                 (filtroModIKeystoreSubject!=null || filtroModIKeystoreIssuer!=null || filtroModITokenClientId!=null)) {
  1701.             
  1702.             ISQLQueryObject sqlOr = sqlQueryObject.newSQLQueryObject();
  1703.             sqlOr.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  1704.             sqlOr.setANDLogicOperator(false);
  1705.             
  1706.             // ramo modi
  1707.             ISQLQueryObject sqlModi = sqlQueryObject.newSQLQueryObject();
  1708.             sqlModi.setANDLogicOperator(true);
  1709.             for (ISQLQueryObject sql : listSqlQueryProtocolProperties) {
  1710.                 sqlModi.addWhereExistsCondition(false, sql);
  1711.             }
  1712.             sqlOr.addWhereCondition(sqlModi.createSQLConditions());
  1713.             
  1714.             // ramo credenzialiBase
  1715.             ISQLQueryObject sqlCredenzialiBase = sqlQueryObject.newSQLQueryObject();
  1716.             sqlCredenzialiBase.setANDLogicOperator(true);
  1717.             String ssl = "ssl";// --> org.openspcoop2.core.config.constants.CredenzialeTipo.SSL.toString();
  1718.             String token = "token";// --> org.openspcoop2.core.config.constants.CredenzialeTipo.TOKEN.toString();
  1719.             if(filtroModITokenClientId!=null) {
  1720.                 sqlCredenzialiBase.addWhereCondition(false,
  1721.                         CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = '"+token+"'",
  1722.                         CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = '"+ssl+"' AND "+CostantiDB.SERVIZI_APPLICATIVI+".token_policy IS NOT NULL");
  1723.             }
  1724.             else {
  1725.                 sqlCredenzialiBase.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".tipoauth = '"+ssl+"'");
  1726.             }
  1727.             if(filtroModITokenClientId!=null) {
  1728.                 sqlCredenzialiBase.addWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI+".utente", 
  1729.                         filtroModITokenClientId, LikeConfig.contains(true,true));
  1730.             }
  1731.             if(filtroModIKeystoreSubject!=null) {
  1732.                 sqlCredenzialiBase.addWhereCondition(false, 
  1733.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI+".cn_subject", filtroModIKeystoreSubject, 
  1734.                                 LikeConfig.contains(true,true)),
  1735.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI+".subject", filtroModIKeystoreSubject, 
  1736.                                 LikeConfig.contains(true,true)));
  1737.             } 
  1738.             if(filtroModIKeystoreIssuer!=null) {
  1739.                 sqlCredenzialiBase.addWhereCondition(false, 
  1740.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI+".cn_issuer", filtroModIKeystoreIssuer, 
  1741.                                 LikeConfig.contains(true,true)),
  1742.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.SERVIZI_APPLICATIVI+".issuer", filtroModIKeystoreIssuer, 
  1743.                                 LikeConfig.contains(true,true)));
  1744.             } 
  1745.             sqlOr.addWhereCondition(sqlCredenzialiBase.createSQLConditions());
  1746.             
  1747.             sqlQueryObject.addWhereCondition(sqlOr.createSQLConditions());
  1748.             
  1749.         }
  1750.         else {
  1751.         
  1752.             if(!listSqlQueryProtocolProperties.isEmpty()) {
  1753.                 for (ISQLQueryObject sql : listSqlQueryProtocolProperties) {
  1754.                     sqlQueryObject.addWhereExistsCondition(false, sql);
  1755.                 }
  1756.             }
  1757.             
  1758.         }
  1759.         
  1760.     }
  1761.     
  1762.     public static void setFiltriModIErogazione(ISQLQueryObject sqlQueryObject, String tipoDB,
  1763.             String filtroModISicurezzaCanale, String filtroModISicurezzaMessaggio,
  1764.             String filtroModISorgenteToken,
  1765.             Boolean filtroModIDigestRichiesta, String filtroModIInfoUtente,
  1766.             String filtroModIKeystore, String filtroModIAudience) throws Exception {
  1767.         setFiltriModIErogazioneFruizione(sqlQueryObject, tipoDB,
  1768.                 filtroModISicurezzaCanale, filtroModISicurezzaMessaggio,
  1769.                 filtroModISorgenteToken,
  1770.                 filtroModIDigestRichiesta, filtroModIInfoUtente,
  1771.                 filtroModIKeystore, filtroModIAudience,
  1772.                 true);
  1773.     }
  1774.     public static void setFiltriModIFruizione(ISQLQueryObject sqlQueryObject, String tipoDB,
  1775.             String filtroModISicurezzaCanale, String filtroModISicurezzaMessaggio,
  1776.             String filtroModISorgenteToken,
  1777.             Boolean filtroModIDigestRichiesta, String filtroModIInfoUtente,
  1778.             String filtroModIKeystore, String filtroModIAudience) throws Exception {
  1779.         setFiltriModIErogazioneFruizione(sqlQueryObject, tipoDB,
  1780.                 filtroModISicurezzaCanale, filtroModISicurezzaMessaggio,
  1781.                 filtroModISorgenteToken,
  1782.                 filtroModIDigestRichiesta, filtroModIInfoUtente,
  1783.                 filtroModIKeystore, filtroModIAudience,
  1784.                 false);
  1785.     }
  1786.     private static void setFiltriModIErogazioneFruizione(ISQLQueryObject sqlQueryObject, String tipoDB,
  1787.             String filtroModISicurezzaCanale, String filtroModISicurezzaMessaggio,
  1788.             String filtroModISorgenteToken,
  1789.             Boolean filtroModIDigestRichiesta, String filtroModIInfoUtente,
  1790.             String filtroModIKeystore, String filtroModIAudience,
  1791.             boolean erogazione) throws Exception {
  1792.         
  1793.         setFiltriModI(sqlQueryObject, tipoDB,
  1794.                 filtroModISicurezzaCanale, filtroModISicurezzaMessaggio,
  1795.                 filtroModISorgenteToken,
  1796.                 filtroModIDigestRichiesta, filtroModIInfoUtente);
  1797.         
  1798.         ProprietariProtocolProperty proprietario = erogazione ? ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA : ProprietariProtocolProperty.FRUITORE;
  1799.         String tabellaDB =  erogazione ? CostantiDB.SERVIZI : CostantiDB.SERVIZI_FRUITORI ;
  1800.         
  1801.         if(filtroModIKeystore!=null) {
  1802.             
  1803.             List<String> query = new ArrayList<>();
  1804.             
  1805.             ISQLQueryObject sqlAccordoKeystore = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1806.                     tipoDB, CostantiDB.MODIPA_KEYSTORE_PATH, null, filtroModIKeystore, null);
  1807.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoKeystore));
  1808.             
  1809.             ISQLQueryObject sqlAccordoTruststore = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1810.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CERTIFICATI_TRUSTSTORE_PATH, null, filtroModIKeystore, null);
  1811.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoTruststore));
  1812.             
  1813.             ISQLQueryObject sqlAccordoTruststoreCrl = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1814.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CERTIFICATI_TRUSTSTORE_CRLS, null, filtroModIKeystore, null);
  1815.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoTruststoreCrl));
  1816.             
  1817.             ISQLQueryObject sqlAccordoTruststoreSsl = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1818.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SSL_TRUSTSTORE_PATH, null, filtroModIKeystore, null);
  1819.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoTruststoreSsl));
  1820.                         
  1821.             if(!query.isEmpty()) {
  1822.                 sqlQueryObject.addWhereCondition(false, query.toArray(new String[1]));
  1823.             }
  1824.         }
  1825.         
  1826.         if(filtroModIAudience!=null) {
  1827.             
  1828.             ISQLQueryObject sqlAudience = buildSQLQueryObjectProtocolProperties(proprietario, tabellaDB,
  1829.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_RICHIESTA_AUDIENCE , null, filtroModIAudience, null);
  1830.             sqlQueryObject.addWhereExistsCondition(false, sqlAudience);
  1831.             
  1832.         }
  1833.         
  1834.     }
  1835.     public static void setFiltriModI(ISQLQueryObject sqlQueryObject, String tipoDB,
  1836.             String filtroModISicurezzaCanale, String filtroModISicurezzaMessaggio,
  1837.             String filtroModISorgenteToken,
  1838.             Boolean filtroModIDigestRichiesta, String filtroModIInfoUtente) throws Exception {
  1839.         
  1840.         if(filtroModISicurezzaCanale!=null) {
  1841.             ISQLQueryObject sql = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE, CostantiDB.ACCORDI,
  1842.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_CANALE, filtroModISicurezzaCanale, null, null);
  1843.             sqlQueryObject.addWhereExistsCondition(false, sql);
  1844.         }
  1845.         if(filtroModISicurezzaMessaggio!=null) {
  1846.             
  1847.             List<String> query = new ArrayList<>();
  1848.             
  1849.             ISQLQueryObject sqlAccordoSec = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE, CostantiDB.ACCORDI,
  1850.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO, filtroModISicurezzaMessaggio, null, null);
  1851.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoSec));
  1852.             
  1853.             addRestCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO, filtroModISicurezzaMessaggio, null);
  1854.             
  1855.             addSoapCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO, filtroModISicurezzaMessaggio, null);
  1856.             
  1857.             if(!query.isEmpty()) {
  1858.                 sqlQueryObject.addWhereCondition(false, query.toArray(new String[1]));
  1859.             }
  1860.         }
  1861.         if(filtroModISorgenteToken!=null) {
  1862.             
  1863.             List<String> query = new ArrayList<>();
  1864.             
  1865.             ISQLQueryObject sqlAccordoSec = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE, CostantiDB.ACCORDI,
  1866.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH, filtroModISorgenteToken, null, null);
  1867.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoSec));
  1868.             
  1869.             addRestCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH, filtroModISorgenteToken, null);
  1870.             
  1871.             addSoapCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_SORGENTE_TOKEN_IDAUTH, filtroModISorgenteToken, null);
  1872.             
  1873.             if(!query.isEmpty()) {
  1874.                 sqlQueryObject.addWhereCondition(false, query.toArray(new String[1]));
  1875.             }
  1876.         }
  1877.         if(filtroModIDigestRichiesta!=null) {
  1878.             
  1879.             List<String> query = new ArrayList<>();
  1880.             
  1881.             ISQLQueryObject sqlAccordoSec = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE, CostantiDB.ACCORDI,
  1882.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_RISPOSTA_REQUEST_DIGEST, null, null, filtroModIDigestRichiesta);
  1883.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoSec));
  1884.             
  1885.             addRestCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_RISPOSTA_REQUEST_DIGEST, null, filtroModIDigestRichiesta);
  1886.             
  1887.             addSoapCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_RISPOSTA_REQUEST_DIGEST, null, filtroModIDigestRichiesta);
  1888.             
  1889.             if(!query.isEmpty()) {
  1890.                 sqlQueryObject.addWhereCondition(false, query.toArray(new String[1]));
  1891.             }
  1892.         }
  1893.         if(filtroModIInfoUtente!=null) {
  1894.             
  1895.             List<String> query = new ArrayList<>();
  1896.             
  1897.             boolean enabled = true;
  1898.             ISQLQueryObject sqlAccordoSec = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE, CostantiDB.ACCORDI,
  1899.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA, null, null, enabled);
  1900.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoSec));
  1901.             
  1902.             addRestCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA, null, enabled);
  1903.             
  1904.             addSoapCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA, null, enabled);
  1905.             
  1906.             if(!query.isEmpty()) {
  1907.                 sqlQueryObject.addWhereCondition(false, query.toArray(new String[1]));
  1908.             }
  1909.             

  1911.             query = new ArrayList<>();
  1912.             
  1913.             ISQLQueryObject sqlAccordoSecPattern = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE, CostantiDB.ACCORDI,
  1914.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN, filtroModIInfoUtente, null, null);
  1915.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoSecPattern));
  1916.             
  1917.             addRestCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN, filtroModIInfoUtente, null);
  1918.             
  1919.             addSoapCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN, filtroModIInfoUtente, null);
  1920.             
  1921.             if(!query.isEmpty()) {
  1922.                 sqlQueryObject.addWhereCondition(false, query.toArray(new String[1]));
  1923.             }
  1924.             
  1925.         }
  1926.                 
  1927.     }
  1928.     private static void addRestCondition(List<String> query, ISQLQueryObject sqlQueryObject, String tipoDB, String nomeProprieta, String valoreProprieta, Boolean valoreProprietaBoolean) throws Exception {
  1929.         String aliasRISORSE = "m_res";
  1930.         ISQLQueryObject sqlREST = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1931.         sqlREST.addFromTable(CostantiDB.API_RESOURCES, aliasRISORSE);
  1932.         sqlREST.setANDLogicOperator(true);
  1933.         sqlREST.addWhereCondition(aliasRISORSE+".id_accordo="+CostantiDB.ACCORDI+".id");
  1934.         ISQLQueryObject sqlRestSec = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.RESOURCE, aliasRISORSE,
  1935.                 tipoDB, nomeProprieta, valoreProprieta, null, valoreProprietaBoolean);
  1936.         sqlREST.addWhereExistsCondition(false, sqlRestSec);
  1937.         query.add(sqlQueryObject.getWhereExistsCondition(false, sqlREST));
  1938.     }
  1939.     private static void addSoapCondition(List<String> query, ISQLQueryObject sqlQueryObject, String tipoDB, String nomeProprieta, String valoreProprieta, Boolean valoreProprietaBoolean) throws Exception {
  1940.         String aliasPORTTYPES = "m_pt";
  1941.         String aliasOPERATIONS = "m_op";
  1942.         ISQLQueryObject sqlSOAP = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1943.         sqlSOAP.addFromTable(CostantiDB.PORT_TYPE, aliasPORTTYPES);
  1944.         sqlSOAP.addFromTable(CostantiDB.PORT_TYPE_AZIONI, aliasOPERATIONS);
  1945.         sqlSOAP.setANDLogicOperator(true);
  1946.         sqlSOAP.addWhereCondition(aliasPORTTYPES+".id_accordo="+CostantiDB.ACCORDI+".id");
  1947.         sqlSOAP.addWhereCondition(aliasOPERATIONS+".id_port_type="+aliasPORTTYPES+".id");
  1948.         ISQLQueryObject sqlSoapSec = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.OPERATION, aliasOPERATIONS,
  1949.                 tipoDB, nomeProprieta, valoreProprieta, null, valoreProprietaBoolean);
  1950.         sqlSOAP.addWhereExistsCondition(false, sqlSoapSec);
  1951.         query.add(sqlQueryObject.getWhereExistsCondition(false, sqlSOAP));
  1952.     }
  1953.     private static ISQLQueryObject buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty tipoProprietario, String tabellaProprietario,
  1954.             String tipoDB, String nomeProprieta, String valoreProprietaEquals, String valoreProprietaContains, Boolean valoreProprietaBoolean) throws Exception {
  1955.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1956.         sql.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  1957.         sql.setANDLogicOperator(true);
  1958.         sql.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES+".id_proprietario="+tabellaProprietario+".id");
  1959.         sql.addWhereLikeCondition(CostantiDB.PROTOCOL_PROPERTIES+".tipo_proprietario", tipoProprietario.name(), false, false, false);
  1960.         sql.addWhereLikeCondition(CostantiDB.PROTOCOL_PROPERTIES+".name", nomeProprieta, false, false, false);
  1961.         if(valoreProprietaContains!=null) {
  1962.             sql.addWhereLikeCondition(CostantiDB.PROTOCOL_PROPERTIES+".value_string", valoreProprietaContains, LikeConfig.contains(true));
  1963.         }
  1964.         else if(valoreProprietaEquals!=null) {
  1965.             sql.addWhereLikeCondition(CostantiDB.PROTOCOL_PROPERTIES+".value_string", valoreProprietaEquals, false, false, false);
  1966.         }
  1967.         if(valoreProprietaBoolean!=null) {
  1968.             if(valoreProprietaBoolean) {
  1969.                 sql.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES+".value_boolean="+CostantiDB.TRUE);
  1970.             }
  1971.             else {
  1972.                 sql.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES+".value_boolean="+CostantiDB.FALSE);
  1973.             }
  1974.         }
  1975.         return sql;
  1976.     }
  1977.     
  1978.     
  1979.     public static void setFiltriProprietaApplicativo(ISQLQueryObject sqlQueryObject, String tipoDB, 
  1980.             String nomeProprieta, String valoreProprieta) throws Exception {
  1981.         setFiltriProprieta(sqlQueryObject, tipoDB, 
  1982.                 ProprietariProtocolProperty.SERVIZIO_APPLICATIVO, null,
  1983.                 nomeProprieta, valoreProprieta);
  1984.     }
  1985.     public static void setFiltriProprietaSoggetto(ISQLQueryObject sqlQueryObject, String tipoDB, 
  1986.             String nomeProprieta, String valoreProprieta) throws Exception {
  1987.         setFiltriProprieta(sqlQueryObject, tipoDB, 
  1988.                 ProprietariProtocolProperty.SOGGETTO, null,
  1989.                 nomeProprieta, valoreProprieta);
  1990.     }
  1991.     public static void setFiltriProprietaErogazione(ISQLQueryObject sqlQueryObject, String tipoDB, 
  1992.             String nomeProprieta, String valoreProprieta) throws Exception {
  1993.         
  1994.         String aliasMAPPING_EROGAZIONE_PA = "c_map";
  1995.         String aliasPORTE_APPLICATIVE = "c_pa";
  1996.         
  1997.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1998.         sql.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA, aliasMAPPING_EROGAZIONE_PA);
  1999.         sql.addFromTable(CostantiDB.PORTE_APPLICATIVE, aliasPORTE_APPLICATIVE);
  2000.         sql.setANDLogicOperator(true);
  2001.         sql.addWhereCondition(aliasMAPPING_EROGAZIONE_PA+".id_erogazione="+CostantiDB.SERVIZI+".id");
  2002.         sql.addWhereCondition(aliasMAPPING_EROGAZIONE_PA+".id_porta="+aliasPORTE_APPLICATIVE+".id");
  2003.         setFiltriProprieta(sql, tipoDB, 
  2004.                 ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA, aliasPORTE_APPLICATIVE,
  2005.                 nomeProprieta, valoreProprieta);
  2006.         sqlQueryObject.addWhereExistsCondition(false, sql);
  2007.         
  2008.     }
  2009.     public static void setFiltriProprietaFruizione(ISQLQueryObject sqlQueryObject, String tipoDB, 
  2010.             String nomeProprieta, String valoreProprieta) throws Exception {
  2011.         
  2012.         String aliasMAPPING_FRUIZIONE_PD = "c_map";
  2013.         String aliasPORTE_DELEGATE = "c_pd";
  2014.         
  2015.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2016.         sql.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD, aliasMAPPING_FRUIZIONE_PD);
  2017.         sql.addFromTable(CostantiDB.PORTE_DELEGATE, aliasPORTE_DELEGATE);
  2018.         sql.setANDLogicOperator(true);
  2019.         sql.addWhereCondition(aliasMAPPING_FRUIZIONE_PD+".id_fruizione="+CostantiDB.SERVIZI_FRUITORI+".id");
  2020.         sql.addWhereCondition(aliasMAPPING_FRUIZIONE_PD+".id_porta="+aliasPORTE_DELEGATE+".id");
  2021.         setFiltriProprieta(sql, tipoDB, 
  2022.                 ProprietariProtocolProperty.FRUITORE, aliasPORTE_DELEGATE,
  2023.                 nomeProprieta, valoreProprieta);
  2024.         sqlQueryObject.addWhereExistsCondition(false, sql);
  2025.         
  2026.     }
  2027.     private static void setFiltriProprieta(ISQLQueryObject sqlQueryObject, String tipoDB, 
  2028.             ProprietariProtocolProperty tipoProprietario, String tabellaAlias,
  2029.             String nomeProprieta, String valoreProprieta) throws Exception {
  2030.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2031.         String nomeTabellaPrincipale = null;
  2032.         String nomeTabellaProprieta = null;
  2033.         String colonnaJoin = null;
  2034.         if(ProprietariProtocolProperty.SERVIZIO_APPLICATIVO.equals(tipoProprietario)) {
  2035.             nomeTabellaPrincipale = CostantiDB.SERVIZI_APPLICATIVI;
  2036.             nomeTabellaProprieta = CostantiDB.SERVIZI_APPLICATIVI_PROPS;
  2037.             colonnaJoin = "id_servizio_applicativo";
  2038.         }
  2039.         else if(ProprietariProtocolProperty.SOGGETTO.equals(tipoProprietario)) {
  2040.             nomeTabellaPrincipale = CostantiDB.SOGGETTI;
  2041.             nomeTabellaProprieta = CostantiDB.SOGGETTI_PROPS;
  2042.             colonnaJoin = "id_soggetto";
  2043.         }
  2044.         else if(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA.equals(tipoProprietario)) {
  2045.             nomeTabellaPrincipale = tabellaAlias;
  2046.             nomeTabellaProprieta = CostantiDB.PORTE_APPLICATIVE_PROP;
  2047.             colonnaJoin = "id_porta";
  2048.         }
  2049.         else if(ProprietariProtocolProperty.FRUITORE.equals(tipoProprietario)) {
  2050.             nomeTabellaPrincipale = tabellaAlias;
  2051.             nomeTabellaProprieta = CostantiDB.PORTE_DELEGATE_PROP;
  2052.             colonnaJoin = "id_porta";
  2053.         }
  2054.         else {
  2055.             throw new Exception("Tipo proprietario '"+tipoProprietario+"' non gestito");
  2056.         }
  2057.         sql.addFromTable(nomeTabellaProprieta);
  2058.         sql.setANDLogicOperator(true);
  2059.         sql.addWhereCondition(nomeTabellaProprieta+"."+colonnaJoin+"="+nomeTabellaPrincipale+".id");
  2060.         if(nomeProprieta!=null) {
  2061.             sql.addWhereLikeCondition(nomeTabellaProprieta+".nome", nomeProprieta, false, false, false);
  2062.         }
  2063.         if(valoreProprieta!=null) {
  2064.             sql.addWhereLikeCondition(nomeTabellaProprieta+".valore", valoreProprieta, LikeConfig.contains(true));
  2065.         }
  2066.         sqlQueryObject.addWhereExistsCondition(false, sql);
  2067.     }
  2068.     
  2069.     
  2070.     
  2071.     public static void setFiltriConfigurazioneErogazione(ISQLQueryObject sqlQueryObject, String tipoDB,
  2072.             String filtroStatoAPIImpl,
  2073.             String filtroAutenticazioneTokenPolicy,
  2074.             String filtroAutenticazioneTrasporto,
  2075.             String filtroRateLimitingStato,
  2076.             String filtroValidazioneStato,
  2077.             String filtroCacheRispostaStato,
  2078.             String filtroMessageSecurityStato,
  2079.             String filtroMTOMStato,
  2080.             String filtroTrasformazione,
  2081.             String filtroConfigurazioneTransazioni,
  2082.             String filtroCorrelazioneApplicativa,
  2083.             String filtroConfigurazioneDumpTipo,
  2084.             String filtroCORS, String filtroCORSOrigin) throws Exception {
  2085.         _setFiltriConfigurazione(sqlQueryObject, tipoDB,
  2086.                 filtroStatoAPIImpl,
  2087.                 filtroAutenticazioneTokenPolicy,
  2088.                 filtroAutenticazioneTrasporto,
  2089.                 filtroRateLimitingStato,
  2090.                 filtroValidazioneStato,
  2091.                 filtroCacheRispostaStato,
  2092.                 filtroMessageSecurityStato,
  2093.                 filtroMTOMStato,
  2094.                 filtroTrasformazione,
  2095.                 filtroConfigurazioneTransazioni,
  2096.                 filtroCorrelazioneApplicativa,
  2097.                 filtroConfigurazioneDumpTipo,
  2098.                 filtroCORS, filtroCORSOrigin, 
  2099.                 true);
  2100.     }
  2101.     public static void setFiltriConfigurazioneFruizione(ISQLQueryObject sqlQueryObject, String tipoDB,
  2102.             String filtroStatoAPIImpl,
  2103.             String filtroAutenticazioneTokenPolicy,
  2104.             String filtroAutenticazioneTrasporto,
  2105.             String filtroRateLimitingStato,
  2106.             String filtroValidazioneStato,
  2107.             String filtroCacheRispostaStato,
  2108.             String filtroMessageSecurityStato,
  2109.             String filtroMTOMStato,
  2110.             String filtroTrasformazione,
  2111.             String filtroConfigurazioneTransazioni,
  2112.             String filtroCorrelazioneApplicativa,
  2113.             String filtroConfigurazioneDumpTipo,
  2114.             String filtroCORS, String filtroCORSOrigin) throws Exception {
  2115.         _setFiltriConfigurazione(sqlQueryObject, tipoDB,
  2116.                 filtroStatoAPIImpl,
  2117.                 filtroAutenticazioneTokenPolicy,
  2118.                 filtroAutenticazioneTrasporto,
  2119.                 filtroRateLimitingStato,
  2120.                 filtroValidazioneStato,
  2121.                 filtroCacheRispostaStato,
  2122.                 filtroMessageSecurityStato,
  2123.                 filtroMTOMStato,
  2124.                 filtroTrasformazione,
  2125.                 filtroConfigurazioneTransazioni,
  2126.                 filtroCorrelazioneApplicativa,
  2127.                 filtroConfigurazioneDumpTipo,
  2128.                 filtroCORS, filtroCORSOrigin,
  2129.                 false);
  2130.     }
  2131.     public static void _setFiltriConfigurazione(ISQLQueryObject sqlQueryObject, String tipoDB,
  2132.             String filtroStatoAPIImpl,
  2133.             String filtroAutenticazioneTokenPolicy,
  2134.             String filtroAutenticazioneTrasporto,
  2135.             String filtroRateLimitingStato,
  2136.             String filtroValidazioneStato,
  2137.             String filtroCacheRispostaStato,
  2138.             String filtroMessageSecurityStato,
  2139.             String filtroMTOMStato,
  2140.             String filtroTrasformazione,
  2141.             String filtroConfigurazioneTransazioni,
  2142.             String filtroCorrelazioneApplicativa,
  2143.             String filtroConfigurazioneDumpTipo,
  2144.             String filtroCORS, String filtroCORSOrigin,
  2145.             boolean erogazioni) throws Exception {

  2147.         String aliasCONFIGPORTA = "conf_p";
  2148.         String aliasCONFIGMAPPING = "conf_m";
  2149.         
  2150.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2151.         if(erogazioni) {
  2152.             sql.addFromTable(CostantiDB.PORTE_APPLICATIVE, aliasCONFIGPORTA);
  2153.             sql.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA, aliasCONFIGMAPPING);
  2154.         }
  2155.         else {
  2156.             sql.addFromTable(CostantiDB.PORTE_DELEGATE, aliasCONFIGPORTA);
  2157.             sql.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD, aliasCONFIGMAPPING);
  2158.         }
  2159.         sql.setANDLogicOperator(true);
  2160.         if(erogazioni) {
  2161.             sql.addWhereCondition(aliasCONFIGMAPPING+".id_erogazione="+CostantiDB.SERVIZI+".id");
  2162.             sql.addWhereCondition(aliasCONFIGMAPPING+".id_porta="+aliasCONFIGPORTA+".id");
  2163.         }
  2164.         else {
  2165.             sql.addWhereCondition(aliasCONFIGMAPPING+".id_fruizione="+CostantiDB.SERVIZI_FRUITORI+".id");
  2166.             sql.addWhereCondition(aliasCONFIGMAPPING+".id_porta="+aliasCONFIGPORTA+".id");
  2167.         }   
  2168.         
  2169.         if(filtroStatoAPIImpl!=null && !"".equals(filtroStatoAPIImpl)) {
  2170.             if(Filtri.FILTRO_CONFIGURAZIONE_STATO_VALORE_ABILITATO.equals(filtroStatoAPIImpl)) {
  2171.                 ISQLQueryObject sqlStato = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2172.                 if(erogazioni) {
  2173.                     sqlStato.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2174.                 }
  2175.                 else {
  2176.                     sqlStato.addFromTable(CostantiDB.PORTE_DELEGATE);
  2177.                 }
  2178.                 sqlStato.setANDLogicOperator(false);
  2179.                 sqlStato.addWhereLikeCondition(aliasCONFIGPORTA+".stato", "abilitato", false, false, false);
  2180.                 sqlStato.addWhereIsNullCondition(aliasCONFIGPORTA+".stato");
  2181.                 sql.addWhereCondition(sqlStato.createSQLConditions());
  2182.             }
  2183.             else if(Filtri.FILTRO_CONFIGURAZIONE_STATO_VALORE_DISABILITATO.equals(filtroStatoAPIImpl)) {
  2184.                 sql.addWhereLikeCondition(aliasCONFIGPORTA+".stato", "disabilitato", false, false, false);
  2185.             }   
  2186.         }
  2187.         
  2188.         if(filtroAutenticazioneTokenPolicy!=null && !"".equals(filtroAutenticazioneTokenPolicy)) {
  2189.             sql.addWhereLikeCondition(aliasCONFIGPORTA+".token_policy", filtroAutenticazioneTokenPolicy, false, false, false);
  2190.         }
  2191.         
  2192.         if(filtroAutenticazioneTrasporto!=null && !"".equals(filtroAutenticazioneTrasporto)) {
  2193.             sql.addWhereLikeCondition(aliasCONFIGPORTA+".autenticazione", filtroAutenticazioneTrasporto, false, false, false);
  2194.         }
  2195.         
  2196.         if(filtroRateLimitingStato!=null && !"".equals(filtroRateLimitingStato)) {
  2197.             String aliasRT = "rt_c";
  2198.             ISQLQueryObject sqlRT = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2199.             sqlRT.addFromTable(CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY, aliasRT);
  2200.             sqlRT.addSelectField(aliasRT, "id");
  2201.             sqlRT.setANDLogicOperator(true);
  2202.             sqlRT.addWhereCondition(aliasCONFIGPORTA+".nome_porta="+aliasRT+".filtro_porta");
  2203.             String ruolo = erogazioni ? "applicativa" : "delegata";
  2204.             sqlRT.addWhereLikeCondition(aliasRT+".filtro_ruolo", ruolo, false, false, false);
  2205.             if(Filtri.FILTRO_CONFIGURAZIONE_RATE_LIMITING_STATO_VALORE_ABILITATO.equals(filtroRateLimitingStato)) {
  2206.                 sql.addWhereExistsCondition(false, sqlRT);  
  2207.             }
  2208.             else if(Filtri.FILTRO_CONFIGURAZIONE_RATE_LIMITING_STATO_VALORE_DISABILITATO.equals(filtroRateLimitingStato)) {
  2209.                 sql.addWhereExistsCondition(true, sqlRT);   
  2210.             }
  2211.         }
  2212.         
  2213.         if(filtroValidazioneStato!=null && !"".equals(filtroValidazioneStato)) {
  2214.             if(Filtri.FILTRO_CONFIGURAZIONE_VALIDAZIONE_STATO_VALORE_ABILITATO.equals(filtroValidazioneStato)) {
  2215.                 sql.addWhereIsNotNullCondition(aliasCONFIGPORTA+".validazione_contenuti_stato");
  2216.             }
  2217.             else if(Filtri.FILTRO_CONFIGURAZIONE_VALIDAZIONE_STATO_VALORE_DISABILITATO.equals(filtroValidazioneStato)) {
  2218.                 sql.addWhereIsNullCondition(aliasCONFIGPORTA+".validazione_contenuti_stato");
  2219.             }
  2220.         }
  2221.         
  2222.         if(filtroCacheRispostaStato!=null && !"".equals(filtroCacheRispostaStato)) {
  2223.             if(Filtri.FILTRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO_VALORE_DISABILITATO.equals(filtroCacheRispostaStato)) {
  2224.                 ISQLQueryObject sqlStato = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2225.                 if(erogazioni) {
  2226.                     sqlStato.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2227.                 }
  2228.                 else {
  2229.                     sqlStato.addFromTable(CostantiDB.PORTE_DELEGATE);
  2230.                 }
  2231.                 sqlStato.setANDLogicOperator(false);
  2232.                 sqlStato.addWhereLikeCondition(aliasCONFIGPORTA+".response_cache_stato", "disabilitato", false, false, false);
  2233.                 sqlStato.addWhereIsNullCondition(aliasCONFIGPORTA+".response_cache_stato");
  2234.                 sql.addWhereCondition(sqlStato.createSQLConditions());
  2235.             }
  2236.             else if(Filtri.FILTRO_CONFIGURAZIONE_CACHE_RISPOSTA_STATO_VALORE_ABILITATO.equals(filtroCacheRispostaStato)) {
  2237.                 sql.addWhereLikeCondition(aliasCONFIGPORTA+".response_cache_stato", "abilitato", false, false, false);
  2238.             }   
  2239.         }
  2240.         
  2241.         if(filtroMessageSecurityStato!=null && !"".equals(filtroMessageSecurityStato)) {
  2242.             if(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_VALORE_ABILITATO.equals(filtroMessageSecurityStato) ||
  2243.                     Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_VALORE_DISABILITATO.equals(filtroMessageSecurityStato)) {
  2244.                 ISQLQueryObject sqlStato = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2245.                 if(erogazioni) {
  2246.                     sqlStato.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2247.                 }
  2248.                 else {
  2249.                     sqlStato.addFromTable(CostantiDB.PORTE_DELEGATE);
  2250.                 }
  2251.                 if(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_VALORE_ABILITATO.equals(filtroMessageSecurityStato)) {
  2252.                     sqlStato.setANDLogicOperator(false);
  2253.                     sqlStato.addWhereIsNotNullCondition(aliasCONFIGPORTA+".security_request_mode");
  2254.                     sqlStato.addWhereIsNotNullCondition(aliasCONFIGPORTA+".security_response_mode");
  2255.                 }
  2256.                 else {
  2257.                     sqlStato.setANDLogicOperator(true);
  2258.                     sqlStato.addWhereIsNullCondition(aliasCONFIGPORTA+".security_request_mode");
  2259.                     sqlStato.addWhereIsNullCondition(aliasCONFIGPORTA+".security_response_mode");
  2260.                 }
  2261.                 sql.addWhereCondition(sqlStato.createSQLConditions());  
  2262.             }
  2263.             else if(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO_VALORE_ABILITATO_RICHIESTA.equals(filtroMessageSecurityStato)) {
  2264.                 sql.addWhereIsNotNullCondition(aliasCONFIGPORTA+".security_request_mode");
  2265.             }
  2266.             else if(Filtri.FILTRO_CONFIGURAZIONE_MESSAGE_SECURITY_STATO_VALORE_ABILITATO_RISPOSTA.equals(filtroMessageSecurityStato)) {
  2267.                 sql.addWhereIsNotNullCondition(aliasCONFIGPORTA+".security_response_mode");
  2268.             }
  2269.         }
  2270.         
  2271.         if(filtroMTOMStato!=null && !"".equals(filtroMTOMStato)) {
  2272.             if(Filtri.FILTRO_CONFIGURAZIONE_MTOM_VALORE_ABILITATO.equals(filtroMTOMStato) ||
  2273.                     Filtri.FILTRO_CONFIGURAZIONE_MTOM_VALORE_DISABILITATO.equals(filtroMTOMStato)) {
  2274.                 ISQLQueryObject sqlStato = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2275.                 if(erogazioni) {
  2276.                     sqlStato.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2277.                 }
  2278.                 else {
  2279.                     sqlStato.addFromTable(CostantiDB.PORTE_DELEGATE);
  2280.                 }
  2281.                 if(Filtri.FILTRO_CONFIGURAZIONE_MTOM_VALORE_ABILITATO.equals(filtroMTOMStato)) {
  2282.                     sqlStato.setANDLogicOperator(false);
  2283.                     sqlStato.addWhereCondition(true,  aliasCONFIGPORTA+".mtom_request_mode is not null", aliasCONFIGPORTA+".mtom_request_mode <> 'disable'");
  2284.                     sqlStato.addWhereCondition(true,  aliasCONFIGPORTA+".mtom_response_mode is not null", aliasCONFIGPORTA+".mtom_response_mode <> 'disable'");
  2285.                 }
  2286.                 else {
  2287.                     sqlStato.setANDLogicOperator(true);
  2288.                     sqlStato.addWhereCondition(false,  aliasCONFIGPORTA+".mtom_request_mode is null", aliasCONFIGPORTA+".mtom_request_mode = 'disable'");
  2289.                     sqlStato.addWhereCondition(false,  aliasCONFIGPORTA+".mtom_response_mode is null", aliasCONFIGPORTA+".mtom_response_mode = 'disable'");
  2290.                 }
  2291.                 sql.addWhereCondition(sqlStato.createSQLConditions());  
  2292.             }
  2293.             else if(Filtri.FILTRO_CONFIGURAZIONE_MTOM_STATO_VALORE_ABILITATO_RICHIESTA.equals(filtroMTOMStato)) {
  2294.                 sql.addWhereCondition(true,  aliasCONFIGPORTA+".mtom_request_mode is not null", aliasCONFIGPORTA+".mtom_request_mode <> 'disable'");
  2295.             }
  2296.             else if(Filtri.FILTRO_CONFIGURAZIONE_MTOM_STATO_VALORE_ABILITATO_RISPOSTA.equals(filtroMTOMStato)) {
  2297.                 sql.addWhereCondition(true,  aliasCONFIGPORTA+".mtom_response_mode is not null", aliasCONFIGPORTA+".mtom_response_mode <> 'disable'");
  2298.             }
  2299.         }
  2300.         
  2301.         if(filtroTrasformazione!=null && !"".equals(filtroTrasformazione)) {        
  2302.             String aliasTRANSFORM = "tra_c";
  2303.             ISQLQueryObject sqlTrasformazione = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2304.             if(erogazioni) {
  2305.                 sqlTrasformazione.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI, aliasTRANSFORM);
  2306.             }
  2307.             else {
  2308.                 sqlTrasformazione.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI, aliasTRANSFORM);
  2309.             }
  2310.             sqlTrasformazione.addSelectField(aliasTRANSFORM, "id");
  2311.             sqlTrasformazione.setANDLogicOperator(true);
  2312.             sqlTrasformazione.addWhereCondition(aliasCONFIGPORTA+".id="+aliasTRANSFORM+".id_porta");
  2313.             sqlTrasformazione.addWhereLikeCondition(aliasTRANSFORM+".stato", "abilitato", false, false, false);
  2314.             sql.addWhereExistsCondition(Filtri.FILTRO_CONFIGURAZIONE_TRASFORMAZIONE_STATO_VALORE_ABILITATO.equals(filtroTrasformazione) ? false : true, sqlTrasformazione);
  2315.         }
  2316.         
  2317.         if(filtroConfigurazioneTransazioni!=null && !"".equals(filtroConfigurazioneTransazioni)) {
  2318.             addFiltroConfigurazioneTransazioni(tipoDB,
  2319.                     aliasCONFIGPORTA,
  2320.                     filtroConfigurazioneTransazioni, erogazioni,
  2321.                     sql);
  2322.         }
  2323.         
  2324.         if(filtroCorrelazioneApplicativa!=null && !"".equals(filtroCorrelazioneApplicativa)) {
  2325.             
  2326.             // Richiesta
  2327.             String aliasCorrelazioneRichiesta = erogazioni ? CostantiDB.PORTE_APPLICATIVE_CORRELAZIONE : CostantiDB.PORTE_DELEGATE_CORRELAZIONE;
  2328.             ISQLQueryObject sqlCorrelazioneRichiesta = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2329.             sqlCorrelazioneRichiesta.addFromTable(aliasCorrelazioneRichiesta);
  2330.             sqlCorrelazioneRichiesta.setANDLogicOperator(true);
  2331.             sqlCorrelazioneRichiesta.addWhereCondition(aliasCONFIGPORTA+".id="+aliasCorrelazioneRichiesta+".id_porta");
  2332.             
  2333.             // Risposta
  2334.             String aliasCorrelazioneRisposta = erogazioni ? CostantiDB.PORTE_APPLICATIVE_CORRELAZIONE_RISPOSTA : CostantiDB.PORTE_DELEGATE_CORRELAZIONE_RISPOSTA;
  2335.             ISQLQueryObject sqlCorrelazioneRisposta = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2336.             sqlCorrelazioneRisposta.addFromTable(aliasCorrelazioneRisposta);
  2337.             sqlCorrelazioneRisposta.setANDLogicOperator(true);
  2338.             sqlCorrelazioneRisposta.addWhereCondition(aliasCONFIGPORTA+".id="+aliasCorrelazioneRisposta+".id_porta");
  2339.             
  2340.             if(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_VALORE_ABILITATO.equals(filtroCorrelazioneApplicativa) ||
  2341.                     Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_VALORE_DISABILITATO.equals(filtroCorrelazioneApplicativa)) {
  2342.                                 
  2343.                 ISQLQueryObject sqlStato = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2344.                 if(erogazioni) {
  2345.                     sqlStato.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  2346.                 }
  2347.                 else {
  2348.                     sqlStato.addFromTable(CostantiDB.PORTE_DELEGATE);
  2349.                 }
  2350.                 if(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_VALORE_ABILITATO.equals(filtroCorrelazioneApplicativa)) {
  2351.                     sqlStato.setANDLogicOperator(false);
  2352.                     sqlStato.addWhereExistsCondition(false, sqlCorrelazioneRichiesta);
  2353.                     sqlStato.addWhereExistsCondition(false, sqlCorrelazioneRisposta);
  2354.                 }
  2355.                 else {
  2356.                     sqlStato.setANDLogicOperator(true);
  2357.                     sqlStato.addWhereExistsCondition(true, sqlCorrelazioneRichiesta);
  2358.                     sqlStato.addWhereExistsCondition(true, sqlCorrelazioneRisposta);
  2359.                 }
  2360.                 sql.addWhereCondition(sqlStato.createSQLConditions());  
  2361.             }
  2362.             else if(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO_VALORE_ABILITATO_RICHIESTA.equals(filtroCorrelazioneApplicativa)) {
  2363.                 sql.addWhereExistsCondition(false, sqlCorrelazioneRichiesta);
  2364.             }
  2365.             else if(Filtri.FILTRO_CONFIGURAZIONE_CORRELAZIONE_APPLICATIVA_STATO_VALORE_ABILITATO_RISPOSTA.equals(filtroCorrelazioneApplicativa)) {
  2366.                 sql.addWhereExistsCondition(false, sqlCorrelazioneRisposta);
  2367.             }
  2368.         }
  2369.         
  2370.         if(filtroConfigurazioneDumpTipo!=null && !"".equals(filtroConfigurazioneDumpTipo)) {
  2371.             addFiltroConfigurazioneDump(tipoDB,
  2372.                     aliasCONFIGPORTA,
  2373.                     filtroConfigurazioneDumpTipo, erogazioni,
  2374.                     sql);
  2375.         }
  2376.         
  2377.         if(filtroCORS!=null && !"".equals(filtroCORS)) {
  2378.             if(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_DEFAULT.equals(filtroCORS)) {
  2379.                 sql.addWhereIsNullCondition(aliasCONFIGPORTA+".cors_stato");
  2380.             }
  2381.             else if(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroCORS)) {
  2382.                 sql.addWhereLikeCondition(aliasCONFIGPORTA+".cors_stato", "abilitato", false, false, false);
  2383.                 
  2384.                 if(filtroCORSOrigin!=null && !"".equals(filtroCORSOrigin)) {
  2385.                     sql.addWhereLikeCondition(aliasCONFIGPORTA+".cors_allow_origins", filtroCORSOrigin, LikeConfig.contains(true));
  2386.                 }
  2387.             }
  2388.             else if(Filtri.FILTRO_CONFIGURAZIONE_CORS_TIPO_VALORE_RIDEFINITO_DISABILITATO.equals(filtroCORS)) {
  2389.                 sql.addWhereLikeCondition(aliasCONFIGPORTA+".cors_stato", "disabilitato", false, false, false);
  2390.             }
  2391.         }
  2392.         
  2393.         sqlQueryObject.addWhereExistsCondition(false, sql);
  2394.     }
  2395.     public static void addFiltroConfigurazioneTransazioni(String tipoDB,
  2396.             String aliasCONFIGPORTA,
  2397.             String filtroConfigurazioneTransazioni, boolean erogazioni,
  2398.             ISQLQueryObject sqlQueryQuery) throws SQLQueryObjectException {

  2400.         if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_DEFAULT.equals(filtroConfigurazioneTransazioni)) {
  2401.             sqlQueryQuery.addWhereCondition(aliasCONFIGPORTA+".tracciamento_stato is NULL OR "+aliasCONFIGPORTA+".tracciamento_stato='"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'");
  2402.         }
  2403.         else {
  2404.             sqlQueryQuery.addWhereCondition(aliasCONFIGPORTA+".tracciamento_stato='"+CostantiDB.STATO_FUNZIONALITA_ABILITATO+"'");
  2405.             
  2406.             String aliasTRANSAZIONICONFIGDB = "trans_cdb";
  2407.             ISQLQueryObject sqlDB = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2408.             sqlDB.addFromTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE, aliasTRANSAZIONICONFIGDB);
  2409.             sqlDB.addSelectField(aliasTRANSAZIONICONFIGDB, CostantiDB.COLUMN_ID_PROPRIETARIO);
  2410.             sqlDB.setANDLogicOperator(true);
  2411.             sqlDB.addWhereCondition(aliasCONFIGPORTA+".id="+aliasTRANSAZIONICONFIGDB+"."+CostantiDB.COLUMN_ID_PROPRIETARIO);
  2412.             sqlDB.addWhereCondition(aliasTRANSAZIONICONFIGDB+".proprietario='"+
  2413.                     (erogazioni ? CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PA : CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD)+"'");    
  2414.             sqlDB.addWhereCondition(aliasTRANSAZIONICONFIGDB+".tipo='"+CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB+"'"); 
  2415.             
  2416.             String aliasTRANSAZIONICONFIGFILETRACE = "trans_cft";
  2417.             ISQLQueryObject sqlFileTrace = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2418.             sqlFileTrace.addFromTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE, aliasTRANSAZIONICONFIGFILETRACE);
  2419.             sqlFileTrace.addSelectField(aliasTRANSAZIONICONFIGFILETRACE, CostantiDB.COLUMN_ID_PROPRIETARIO);
  2420.             sqlFileTrace.setANDLogicOperator(true);
  2421.             sqlFileTrace.addWhereCondition(aliasCONFIGPORTA+".id="+aliasTRANSAZIONICONFIGFILETRACE+"."+CostantiDB.COLUMN_ID_PROPRIETARIO);
  2422.             sqlFileTrace.addWhereCondition(aliasTRANSAZIONICONFIGFILETRACE+".proprietario='"+
  2423.                     (erogazioni ? CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PA : CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD)+"'");    
  2424.             sqlFileTrace.addWhereCondition(aliasTRANSAZIONICONFIGFILETRACE+".tipo='"+CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE+"'");    
  2425.         
  2426.             if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_O_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2427.                     ||
  2428.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_DATABASE.equals(filtroConfigurazioneTransazioni)
  2429.                     ||
  2430.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_E_FILETRACE.equals(filtroConfigurazioneTransazioni)) {
  2431.                 sqlDB.addWhereCondition(aliasTRANSAZIONICONFIGDB+".stato<>'"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'");   
  2432.             }
  2433.             else {
  2434.                 sqlDB.addWhereCondition(aliasTRANSAZIONICONFIGDB+".stato='"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'");    
  2435.             }
  2436.             
  2437.             if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_O_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2438.                 ||
  2439.                 Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2440.                 ||
  2441.                 Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_E_FILETRACE.equals(filtroConfigurazioneTransazioni)) {
  2442.                 sqlFileTrace.addWhereCondition(aliasTRANSAZIONICONFIGFILETRACE+".stato<>'"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'"); 
  2443.             }
  2444.             else {
  2445.                 sqlFileTrace.addWhereCondition(aliasTRANSAZIONICONFIGFILETRACE+".stato='"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'");  
  2446.             }
  2447.             
  2448.             if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_O_FILETRACE.equals(filtroConfigurazioneTransazioni)) {
  2449.                 ISQLQueryObject sqlUtilsDB = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2450.                 ISQLQueryObject sqlUtilsFileTrace = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2451.                 sqlQueryQuery.addWhereCondition(false, 
  2452.                         sqlUtilsDB.getWhereExistsCondition(false, sqlDB),
  2453.                         sqlUtilsFileTrace.getWhereExistsCondition(false, sqlFileTrace));
  2454.             }
  2455.             else if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_DATABASE.equals(filtroConfigurazioneTransazioni)
  2456.                     ||
  2457.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2458.                     ||
  2459.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_E_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2460.                     ||
  2461.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_DISABILITATO.equals(filtroConfigurazioneTransazioni)) {
  2462.                 sqlQueryQuery.addWhereExistsCondition(false, sqlDB);
  2463.                 sqlQueryQuery.addWhereExistsCondition(false, sqlFileTrace);
  2464.             }
  2465.         }
  2466.         
  2467.     }
  2468.     public static void addFiltroConfigurazioneDump(String tipoDB,
  2469.             String aliasCONFIGPORTA,
  2470.             String filtroConfigurazioneDumpTipo, boolean erogazioni,
  2471.             ISQLQueryObject sqlQueryQuery) throws SQLQueryObjectException {

  2473.         String aliasDUMPCONFIG = "dump_c";
  2474.         
  2475.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2476.         sql.addFromTable(CostantiDB.DUMP_CONFIGURAZIONE, aliasDUMPCONFIG);
  2477.         sql.addSelectField(aliasDUMPCONFIG, CostantiDB.COLUMN_ID_PROPRIETARIO);
  2478.         sql.setANDLogicOperator(true);
  2479.         if(erogazioni) {
  2480.             sql.addWhereCondition(aliasCONFIGPORTA+".id="+aliasDUMPCONFIG+"."+CostantiDB.COLUMN_ID_PROPRIETARIO);
  2481.             sql.addWhereLikeCondition(aliasDUMPCONFIG+".proprietario", "pa", false, false, false);
  2482.         }
  2483.         else {
  2484.             sql.addWhereCondition(aliasCONFIGPORTA+".id="+aliasDUMPCONFIG+"."+CostantiDB.COLUMN_ID_PROPRIETARIO);
  2485.             sql.addWhereLikeCondition(aliasDUMPCONFIG+".proprietario", "pd", false, false, false);
  2486.         }   
  2487.         
  2488.         //Prepariamo anzi una utility per ogni singola voce e poi ad ogni if la si chiama!
  2489.         
  2490.         boolean and = true;
  2491.         boolean or = false;
  2492.         boolean notExists = true;
  2493.         boolean exists = false;
  2494.         
  2495.         if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_DEFAULT.equals(filtroConfigurazioneDumpTipo)) {
  2496.             sqlQueryQuery.addWhereExistsCondition(notExists, sql);  
  2497.         }
  2498.         else if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2499.                 ||
  2500.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2501.                 ||
  2502.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2503.                 ||
  2504.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2505.                 ||
  2506.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2507.                 ||
  2508.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2509.                 ||
  2510.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2511.                 ||
  2512.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2513.                 ||
  2514.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2515.                 ||
  2516.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2517.                 ||
  2518.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2519.                 ||
  2520.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2521.                 ||
  2522.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2523.                 ||
  2524.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2525.                 ){
  2526.             
  2527.             boolean soloHeader = (
  2528.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2529.                     ||
  2530.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2531.                     ||
  2532.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2533.                     ||
  2534.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2535.                     ||
  2536.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2537.                     ||
  2538.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2539.                     ||
  2540.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2541.                     );
  2542.             BooleanNullable payload = soloHeader ? BooleanNullable.FALSE() : BooleanNullable.TRUE();
  2543.             BooleanNullable headers = BooleanNullable.TRUE();
  2544.             
  2545.             boolean condizionePayloadHeaders = soloHeader ? and : or;
  2546.             
  2547.             List<ISQLQueryObject> sqlMessages = new ArrayList<>();
  2548.             
  2549.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2550.                     ||
  2551.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2552.                     ||
  2553.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2554.                     ||
  2555.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2556.                     ||
  2557.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2558.                     ||
  2559.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2560.                     ) {
  2561.                 ISQLQueryObject sqlRichiestaIngresso = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2562.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2563.                         aliasDUMPCONFIG, 
  2564.                         "id_richiesta_ingresso", payload, headers, condizionePayloadHeaders,
  2565.                         sqlRichiestaIngresso, exists);
  2566.                 sqlMessages.add(sqlRichiestaIngresso);
  2567.             }
  2568.             
  2569.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2570.                     ||
  2571.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2572.                     ||
  2573.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2574.                     ||
  2575.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2576.                     ||
  2577.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2578.                     ||
  2579.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2580.                     ) {
  2581.                 ISQLQueryObject sqlRichiestaUscita = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2582.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2583.                         aliasDUMPCONFIG, 
  2584.                         "id_richiesta_uscita", payload, headers, condizionePayloadHeaders,
  2585.                         sqlRichiestaUscita, exists);
  2586.                 sqlMessages.add(sqlRichiestaUscita);
  2587.             }
  2588.             
  2589.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2590.                     ||
  2591.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2592.                     ||
  2593.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2594.                     ||
  2595.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2596.                     ||
  2597.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2598.                     ||
  2599.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2600.                     ) {
  2601.                 ISQLQueryObject sqlRispostaIngresso = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2602.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2603.                         aliasDUMPCONFIG, 
  2604.                         "id_risposta_ingresso", payload, headers, condizionePayloadHeaders,
  2605.                         sqlRispostaIngresso, exists);
  2606.                 sqlMessages.add(sqlRispostaIngresso);
  2607.             }
  2608.             
  2609.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2610.                     ||
  2611.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2612.                     ||
  2613.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2614.                     ||
  2615.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2616.                     ||
  2617.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2618.                     ||
  2619.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2620.                     ) {
  2621.                 ISQLQueryObject sqlRispostaUscita = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2622.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2623.                         aliasDUMPCONFIG, 
  2624.                         "id_risposta_uscita", payload, headers, condizionePayloadHeaders,
  2625.                         sqlRispostaUscita, exists);
  2626.                 sqlMessages.add(sqlRispostaUscita);
  2627.             }
  2628.             
  2629.             setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2630.                     sql, or,
  2631.                     sqlMessages.toArray(new ISQLQueryObject[1]));
  2632.             sqlQueryQuery.addWhereExistsCondition(exists, sql); 
  2633.         }
  2634.         else if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO.equals(filtroConfigurazioneDumpTipo)
  2635.                 ||
  2636.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2637.                 ||
  2638.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2639.                 ){
  2640.             
  2641.             BooleanNullable payload = BooleanNullable.FALSE();
  2642.             BooleanNullable headers = BooleanNullable.FALSE();
  2643.             
  2644.             boolean condizionePayloadHeaders = and;
  2645.             
  2646.             List<ISQLQueryObject> sqlMessages = new ArrayList<>();
  2647.             
  2648.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO.equals(filtroConfigurazioneDumpTipo)
  2649.                     ||
  2650.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2651.                     ) {
  2652.                 ISQLQueryObject sqlRichiestaIngresso = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2653.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2654.                         aliasDUMPCONFIG, 
  2655.                         "id_richiesta_ingresso", payload, headers, condizionePayloadHeaders,
  2656.                         sqlRichiestaIngresso, exists);
  2657.                 sqlMessages.add(sqlRichiestaIngresso);
  2658.                 
  2659.                 ISQLQueryObject sqlRichiestaUscita = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2660.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2661.                         aliasDUMPCONFIG, 
  2662.                         "id_richiesta_uscita", payload, headers, condizionePayloadHeaders,
  2663.                         sqlRichiestaUscita, exists);
  2664.                 sqlMessages.add(sqlRichiestaUscita);
  2665.             }

  2667.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO.equals(filtroConfigurazioneDumpTipo)
  2668.                     ||
  2669.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2670.                     ) {
  2671.                 ISQLQueryObject sqlRispostaIngresso = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2672.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2673.                         aliasDUMPCONFIG, 
  2674.                         "id_risposta_ingresso", payload, headers, condizionePayloadHeaders,
  2675.                         sqlRispostaIngresso, exists);
  2676.                 sqlMessages.add(sqlRispostaIngresso);
  2677.             
  2678.                 ISQLQueryObject sqlRispostaUscita = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2679.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2680.                         aliasDUMPCONFIG, 
  2681.                         "id_risposta_uscita", payload, headers, condizionePayloadHeaders,
  2682.                         sqlRispostaUscita, exists);
  2683.                 sqlMessages.add(sqlRispostaUscita);
  2684.             }
  2685.             
  2686.             setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2687.                     sql, and,
  2688.                     sqlMessages.toArray(new ISQLQueryObject[1]));
  2689.             sqlQueryQuery.addWhereExistsCondition(exists, sql); 
  2690.         }
  2691.         
  2692.     }
  2693.     private static void setFiltriDumpRegolaConfigurazioneDumpEngine(String tipoDB,
  2694.             ISQLQueryObject sqlQueryObjectConditions, boolean and,
  2695.             ISQLQueryObject ... sqlQueryObjectMessage) throws SQLQueryObjectException {     
  2696.         List<String> conditions = new ArrayList<>();
  2697.         
  2698.         if(tipoDB!=null) {
  2699.             // ignore
  2700.         }
  2701.         
  2702.         if(sqlQueryObjectMessage!=null && sqlQueryObjectMessage.length>0) {
  2703.             for (ISQLQueryObject sql : sqlQueryObjectMessage) {
  2704.                 conditions.add(sql.createSQLConditions());  
  2705.             }
  2706.         }
  2707.         
  2708.         if(conditions.isEmpty()) {
  2709.             throw new SQLQueryObjectException("Usage error");
  2710.         }
  2711.         sqlQueryObjectConditions.addWhereCondition(and, conditions.toArray(new String[1]));
  2712.     }
  2713.     private static void setFiltriDumpRegolaConfigurazioneDumpEngine(String tipoDB,
  2714.             String aliasDUMPCONFIG, 
  2715.             String colonna, BooleanNullable payload, BooleanNullable headers, boolean and,
  2716.             ISQLQueryObject sqlQueryObjectConditions, boolean notExists) throws SQLQueryObjectException {
  2717.         
  2718.         if(tipoDB!=null) {
  2719.             // ignore
  2720.         }
  2721.         
  2722.         String aliasDUMPCONFIGREGOLE = "dump_cr";
  2723.         
  2724.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2725.         sql.addSelectField("id");
  2726.         sql.addFromTable(CostantiDB.DUMP_CONFIGURAZIONE_REGOLA, aliasDUMPCONFIGREGOLE);
  2727.         sql.setANDLogicOperator(true);
  2728.         sql.addWhereCondition(aliasDUMPCONFIG+"."+colonna+"="+aliasDUMPCONFIGREGOLE+".id");
  2729.         if(payload!=null && payload.getValue()!=null &&
  2730.                 headers!=null && headers.getValue()!=null) {
  2731.             sql.addWhereCondition(and, 
  2732.                     sql.getWhereLikeCondition("payload", payload.getValue()!=null && payload.getValue().booleanValue() ? "abilitato" : "disabilitato", false, false, false),
  2733.                     sql.getWhereLikeCondition("headers", headers.getValue()!=null && headers.getValue().booleanValue() ? "abilitato" : "disabilitato", false, false, false));
  2734.         }
  2735.         else if(payload!=null && payload.getValue()!=null) {
  2736.             sql.addWhereLikeCondition("payload", payload.getValue()!=null && payload.getValue().booleanValue() ? "abilitato" : "disabilitato", false, false, false);
  2737.         }
  2738.         else if(headers!=null && headers.getValue()!=null) {
  2739.             sql.addWhereLikeCondition("headers", headers.getValue()!=null && headers.getValue().booleanValue() ? "abilitato" : "disabilitato", false, false, false);
  2740.         }
  2741.         else {
  2742.             throw new SQLQueryObjectException("Usage error");
  2743.         }
  2744.         sqlQueryObjectConditions.addWhereExistsCondition(notExists, sql);
  2745.     }
  2746.     
  2747.     

  2749.     /**
  2750.      * Utility per formattare la string sql con i parametri passati, e stamparla per debug
  2751.      * @param sql la string sql utilizzata nel prepared statement
  2752.      * @param params i parametri da inserire nella stringa che sostituiranno i '?'
  2753.      * @return La stringa sql con al posto dei '?' ha i parametri passati
  2754.      */
  2755.     public static String formatSQLString(String sql,Object ... params)
  2756.     {
  2757.         String res = sql;

  2759.         for (int i = 0; i < params.length; i++)
  2760.         {
  2761.             res=res.replaceFirst("\\?", "{"+i+"}");
  2762.         }

  2764.         return MessageFormat.format(res, params);

  2766.     }


  2769.     
  2770.     
  2771.     
  2772.     public static List<String> convertToList(String v){
  2773.         List<String> l = new ArrayList<>();
  2774.         if(v!=null && !"".equals(v)) {
  2775.             if(v.contains(",")) {
  2776.                 String [] tmp = v.split(",");
  2777.                 for (int i = 0; i < tmp.length; i++) {
  2778.                     l.add(tmp[i].trim());
  2779.                 }
  2780.             }else {
  2781.                 l.add(v.trim());
  2782.             }
  2783.         }
  2784.         return l;
  2785.     }
  2786. }

Created with JaCoCo 0.8.8.202204050719