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.     public static String estraiTipoDatabaseFromLocation(String location)throws CoreException{
  73.         if(location==null){
  74.             throw new CoreException("Location del db is null");
  75.         }
  76.         if(location.indexOf("@")==-1){
  77.             throw new CoreException("Tipo di database non indicato nella location, sintassi corretta e' tipoDatabase@datasource");
  78.         }
  79.         String tipoDatabase = location.split("@")[0].trim();
  80.         if( ! TipiDatabase.isAMember(tipoDatabase)){
  81.             throw new CoreException("Tipo di database indicato nella location ["+tipoDatabase+"] non supportato");
  82.         }
  83.         return tipoDatabase;
  84.     }
  85.     
  86.     
  87.     public static List<List<Object>> readCustom(Logger log, Connection connection, String tipoDB,
  88.             ISQLQueryObject sqlQueryObject, List<Class<?>> returnTypes, List<JDBCObject> paramTypes) throws CoreException
  89.     {
  90.         PreparedStatement stm = null;
  91.         ResultSet rs = null;
  92.         try
  93.         {
  94.             if(returnTypes==null || returnTypes.isEmpty()){
  95.                 throw new CoreException("Non sono stati definiti tipi da ritornare");
  96.             }
  97.             
  98.             List<List<Object>> lista = new ArrayList<>();
  99.             
  100.             String sql = sqlQueryObject.createSQLQuery();
  101.             stm=connection.prepareStatement(sql);
  102.             GenericJDBCParameterUtilities jdbcParameterUtilities = new GenericJDBCParameterUtilities(TipiDatabase.toEnumConstant(tipoDB));
  103.             JDBCObject [] paramsArray = null;
  104.             if(paramTypes!=null && !paramTypes.isEmpty()){
  105.                 paramsArray = paramTypes.toArray(new JDBCObject[1]);
  106.             }
  107.             jdbcParameterUtilities.setParameters(stm, paramsArray);
  108.             
  109.             JDBCSqlLogger sqlLogger = new JDBCSqlLogger(log);
  110.             sqlLogger.infoSql(sql, paramsArray);
  111.             
  112.             rs=stm.executeQuery();

  114.             while(rs.next()){
  115.                 
  116.                 List<Object> listaInterna = new ArrayList<>();
  117.                 
  118.                 for (int i = 0; i < returnTypes.size(); i++) {
  119.                     listaInterna.add(jdbcParameterUtilities.readParameter(rs, (i+1), returnTypes.get(i)));
  120.                 }
  121.                 
  122.                 lista.add(listaInterna);
  123.             }

  125.             return lista;

  127.         }catch (Exception e) {
  128.             throw new CoreException(e);
  129.         }finally
  130.         {
  131.             //Chiudo statement and resultset
  132.             JDBCUtilities.closeResources(rs, stm);

  134.         }
  135.     }
  136.     
  137.     
  138.     
  139.     
  140.     /**
  141.      * Recupera l'id del soggetto in base al nome e al tipo passati come parametri
  142.      * @param nomeSoggetto
  143.      * @param tipoSoggetto
  144.      * @param con
  145.      * @return L'id del soggetto se esiste, altrimenti -1
  146.      * @throws CoreException 
  147.      */
  148.     public static long getIdSoggetto(String nomeSoggetto, String tipoSoggetto,Connection con, String tipoDB) throws CoreException
  149.     {
  150.         return DBUtils.getIdSoggetto(nomeSoggetto, tipoSoggetto, con, tipoDB, CostantiDB.SOGGETTI);
  151.     }
  152.     public static long getIdSoggetto(String nomeSoggetto, String tipoSoggetto,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  153.     {
  154.         PreparedStatement stm = null;
  155.         ResultSet rs = null;
  156.         long idSoggetto=-1;
  157.         try
  158.         {
  159.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  160.             sqlQueryObject.addFromTable(tabellaSoggetti);
  161.             sqlQueryObject.addSelectField("*");
  162.             sqlQueryObject.addWhereCondition("tipo_soggetto = ?");
  163.             sqlQueryObject.addWhereCondition("nome_soggetto = ?");
  164.             sqlQueryObject.setANDLogicOperator(true);
  165.             String query = sqlQueryObject.createSQLQuery();
  166.             stm=con.prepareStatement(query);
  167.             stm.setString(1, tipoSoggetto);
  168.             stm.setString(2, nomeSoggetto);

  170.             rs=stm.executeQuery();

  172.             if(rs.next()){
  173.                 idSoggetto = rs.getLong("id");
  174.             }

  176.             return idSoggetto;

  178.         }catch (Exception e) {
  179.             throw new CoreException(e);
  180.         }finally
  181.         {
  182.             //Chiudo statement and resultset
  183.             JDBCUtilities.closeResources(rs, stm);

  185.         }
  186.     }
  187.     
  188.     public static IDSoggetto getIdSoggetto(long id,Connection con, String tipoDB) throws CoreException
  189.     {
  190.         return DBUtils.getIdSoggetto(id, con, tipoDB, CostantiDB.SOGGETTI);
  191.     }
  192.     public static IDSoggetto getIdSoggetto(long id,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  193.     {
  194.         PreparedStatement stm = null;
  195.         ResultSet rs = null;
  196.         IDSoggetto idSoggetto = null;
  197.         try
  198.         {
  199.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  200.             sqlQueryObject.addFromTable(tabellaSoggetti);
  201.             sqlQueryObject.addSelectField("*");
  202.             sqlQueryObject.addWhereCondition(WHERE_ID_CONDITION);
  203.             sqlQueryObject.setANDLogicOperator(true);
  204.             String query = sqlQueryObject.createSQLQuery();
  205.             stm=con.prepareStatement(query);
  206.             stm.setLong(1, id);

  208.             rs=stm.executeQuery();

  210.             if(rs.next()){
  211.                 String tipSoggetto = rs.getString("tipo_soggetto");
  212.                 String nomeSoggetto = rs.getString("nome_soggetto");
  213.                 idSoggetto = new IDSoggetto(tipSoggetto, nomeSoggetto);
  214.             }

  216.             return idSoggetto;

  218.         }catch (Exception e) {
  219.             throw new CoreException(e);
  220.         }finally
  221.         {
  222.             //Chiudo statement and resultset
  223.             JDBCUtilities.closeResources(rs, stm);

  225.         }
  226.     }
  227.     
  228.     
  229.     
  230.     

  232.     public static long getIdConnettore(String nomeConnettore,Connection con, String tipoDB) throws CoreException
  233.     {
  234.         PreparedStatement stm = null;
  235.         ResultSet rs = null;
  236.         long idConnettore=-1;
  237.         try
  238.         {
  239.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  240.             sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  241.             sqlQueryObject.addSelectField("*");
  242.             sqlQueryObject.addWhereCondition("nome_connettore = ?");
  243.             String query = sqlQueryObject.createSQLQuery();
  244.             stm=con.prepareStatement(query);
  245.             stm.setString(1, nomeConnettore);
  246.             rs=stm.executeQuery();

  248.             if(rs.next()){
  249.                 idConnettore = rs.getLong("id");
  250.             }

  252.             return idConnettore;

  254.         }catch (Exception e) {
  255.             throw new CoreException(e);
  256.         }finally
  257.         {
  258.             //Chiudo statement and resultset
  259.             JDBCUtilities.closeResources(rs, stm);

  261.         }
  262.     }

  264.     
  265.     
  266.     /**
  267.      * Recupero l'id del servizio
  268.      */
  269.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,Connection con, String tipoDB) throws CoreException{
  270.         return DBUtils.getIdServizio(nomeServizio,tipoServizio,versioneServizio,nomeSoggettoErogatore,tipoSoggettoErogatore,con,false,tipoDB, CostantiDB.SOGGETTI);
  271.     }
  272.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  273.         return DBUtils.getIdServizio(nomeServizio,tipoServizio,versioneServizio,nomeSoggettoErogatore,tipoSoggettoErogatore,con,false,tipoDB,tabellaSoggetti);
  274.     }
  275.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, long idSoggetto,Connection con, String tipoDB) throws CoreException{
  276.         return DBUtils.getIdServizio(nomeServizio,tipoServizio,versioneServizio,idSoggetto,con,false,tipoDB, CostantiDB.SOGGETTI);
  277.     }
  278.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, long idSoggetto,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException{
  279.         return DBUtils.getIdServizio(nomeServizio,tipoServizio,versioneServizio,idSoggetto,con,false,tipoDB,tabellaSoggetti);
  280.     }

  282.     /**
  283.      * Recupero l'id del servizio
  284.      */
  285.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,
  286.             Connection con,boolean testServizioNonCorrelato,String tipoDB) throws CoreException
  287.     {
  288.         return DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeSoggettoErogatore, tipoSoggettoErogatore, con, testServizioNonCorrelato, tipoDB, CostantiDB.SOGGETTI);
  289.     }
  290.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,
  291.             Connection con,boolean testServizioNonCorrelato,String tipoDB,String tabellaSoggetti) throws CoreException
  292.     {
  293.         long idSoggetto = DBUtils.getIdSoggetto(nomeSoggettoErogatore, tipoSoggettoErogatore, con, tipoDB,tabellaSoggetti);
  294.         return getIdServizio(nomeServizio, tipoServizio, versioneServizio, idSoggetto,
  295.                 con, testServizioNonCorrelato, tipoDB, tabellaSoggetti);
  296.     }
  297.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, long idSoggetto,
  298.             Connection con,boolean testServizioNonCorrelato,String tipoDB) throws CoreException
  299.     {
  300.         return  getIdServizio(nomeServizio, tipoServizio, versioneServizio, idSoggetto,
  301.                 con,testServizioNonCorrelato,tipoDB,CostantiDB.SOGGETTI);
  302.     }
  303.     public static long getIdServizio(String nomeServizio, String tipoServizio,Integer versioneServizio, long idSoggetto,
  304.             Connection con,boolean testServizioNonCorrelato,String tipoDB,String tabellaSoggetti) throws CoreException
  305.     {
  306.         PreparedStatement stm = null;
  307.         ResultSet rs = null;
  308.         long idServizio=0;
  309.         try
  310.         {
  311.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  312.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  313.             sqlQueryObject.addSelectField("*");
  314.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  315.             sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  316.             sqlQueryObject.addWhereCondition("nome_servizio = ?");
  317.             sqlQueryObject.addWhereCondition("versione_servizio = ?");
  318.             sqlQueryObject.setANDLogicOperator(true);
  319.             String query = sqlQueryObject.createSQLQuery();
  320.             if(testServizioNonCorrelato)
  321.                 query = query + " AND servizio_correlato=?";
  322.             stm=con.prepareStatement(query);
  323.             int index = 1;
  324.             stm.setLong(index++, idSoggetto);
  325.             stm.setString(index++, tipoServizio);
  326.             stm.setString(index++, nomeServizio);
  327.             stm.setInt(index++, versioneServizio);
  328.             if(testServizioNonCorrelato)
  329.                 stm.setString(index++, CostantiDB.STATO_FUNZIONALITA_DISABILITATO);

  331.             rs=stm.executeQuery();

  333.             if(rs.next()){
  334.                 idServizio = rs.getLong("id");
  335.             }

  337.             return idServizio;

  339.         }catch (Exception e) {
  340.             throw new CoreException(e);
  341.         }finally
  342.         {
  343.             //Chiudo statement and resultset
  344.             JDBCUtilities.closeResources(rs, stm);

  346.         }
  347.     }

  349.     
  350.     
  351.     
  352.     
  353.     
  354.     public static String getSuperUserSoggettoSafe(Logger log, String method,
  355.             long idSoggetto,Connection con, String tipoDB) 
  356.     {
  357.         return getSuperUserSoggettoSafe(log, method,
  358.                 idSoggetto,con, tipoDB,CostantiDB.SOGGETTI);
  359.     }
  360.     public static String getSuperUserSoggettoSafe(Logger log, String method,
  361.             long idSoggetto,Connection con, String tipoDB,String tabellaSoggetti) 
  362.     {
  363.         try
  364.         {
  365.             return getSuperUserSoggetto(idSoggetto, con, tipoDB, tabellaSoggetti);
  366.         }catch(Exception e) {
  367.             if(log!=null) {
  368.                 String msgError = "["+method+"] getSuperUserSoggetto failed: "+e.getMessage();
  369.                 log.error(msgError, e);
  370.             }
  371.             return null;
  372.         }
  373.     }
  374.     public static String getSuperUserSoggetto(long idSoggetto,Connection con, String tipoDB) throws CoreException
  375.     {
  376.         return getSuperUserSoggetto(idSoggetto, con, tipoDB, CostantiDB.SOGGETTI);
  377.     }
  378.     public static String getSuperUserSoggetto(long idSoggetto,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  379.     {
  380.         PreparedStatement stm = null;
  381.         ResultSet rs = null;
  382.         String superuser=null;
  383.         try
  384.         {
  385.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  386.             sqlQueryObject.addFromTable(tabellaSoggetti);
  387.             sqlQueryObject.addSelectField("superuser");
  388.             sqlQueryObject.addWhereCondition(WHERE_ID_CONDITION);
  389.             sqlQueryObject.setANDLogicOperator(true);
  390.             String query = sqlQueryObject.createSQLQuery();
  391.             stm=con.prepareStatement(query);
  392.             stm.setLong(1, idSoggetto);

  394.             rs=stm.executeQuery();

  396.             if(rs.next()){
  397.                 superuser = rs.getString("superuser");
  398.             }

  400.             return superuser;

  402.         }
  403.         catch (Exception e) {
  404.             throw new CoreException(e);
  405.         }finally
  406.         {
  407.             //Chiudo statement and resultset
  408.             JDBCUtilities.closeResources(rs, stm);

  410.         }
  411.     }
  412.     
  413.     
  414.     
  415.     
  416.     
  417.     
  418.     
  419.     
  420.     
  421.     public static String getSuperUserServizioSafe(Logger log, String method,
  422.             long idServizio,Connection con, String tipoDB) 
  423.     {
  424.         try
  425.         {
  426.             return getSuperUserServizio(idServizio, con, tipoDB);
  427.         }catch(Exception e) {
  428.             if(log!=null) {
  429.                 String msgError = "["+method+"] getSuperUserServizio failed: "+e.getMessage();
  430.                 log.error(msgError, e);
  431.             }
  432.             return null;
  433.         }
  434.     }
  435.     public static String getSuperUserServizio(long idServizio,Connection con, String tipoDB) throws CoreException
  436.     {
  437.         PreparedStatement stm = null;
  438.         ResultSet rs = null;
  439.         String superuser=null;
  440.         try
  441.         {
  442.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  443.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  444.             sqlQueryObject.addSelectField("superuser");
  445.             sqlQueryObject.addWhereCondition(WHERE_ID_CONDITION);
  446.             sqlQueryObject.setANDLogicOperator(true);
  447.             String query = sqlQueryObject.createSQLQuery();
  448.             stm=con.prepareStatement(query);
  449.             stm.setLong(1, idServizio);

  451.             rs=stm.executeQuery();

  453.             if(rs.next()){
  454.                 superuser = rs.getString("superuser");
  455.             }

  457.             return superuser;

  459.         }
  460.         catch (Exception e) {
  461.             throw new CoreException(e);
  462.         }finally
  463.         {
  464.             //Chiudo statement and resultset
  465.             JDBCUtilities.closeResources(rs, stm);

  467.         }
  468.     }
  469.     
  470.     
  471.     
  472.     
  473.     
  474.     

  476.     public static long getIdPortaApplicativa(String nomePorta, Connection con, String tipoDB) throws CoreException
  477.     {
  478.         PreparedStatement stm = null;
  479.         ResultSet rs = null;
  480.         long idPortaApplicativa=-1;

  482.         try
  483.         {
  484.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  485.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  486.             sqlQueryObject.addSelectField("id");
  487.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  488.             sqlQueryObject.setANDLogicOperator(true);
  489.             String sqlQuery = sqlQueryObject.createSQLQuery();
  490.             stm=con.prepareStatement(sqlQuery);
  491.             stm.setString(1, nomePorta);

  493.             rs=stm.executeQuery();

  495.             if(rs.next())
  496.             {
  497.                 idPortaApplicativa=rs.getLong("id");
  498.             }
  499.             return idPortaApplicativa;
  500.         }catch (Exception e) {
  501.             throw new CoreException(e);
  502.         }finally
  503.         {
  504.             //Chiudo statement and resultset
  505.             JDBCUtilities.closeResources(rs, stm);

  507.         }

  509.     }
  510.     
  511.     
  512.     
  513.     
  514.     
  515.     
  516.     public static long getIdPortaDelegata(String nomePorta, Connection con, String tipoDB) throws CoreException
  517.     {
  518.         PreparedStatement stm = null;
  519.         ResultSet rs = null;
  520.         long idPortaDelegata=-1;

  522.         try
  523.         {
  524.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  525.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  526.             sqlQueryObject.addSelectField("id");
  527.             sqlQueryObject.addWhereCondition("nome_porta = ?");
  528.             sqlQueryObject.setANDLogicOperator(true);
  529.             String sqlQuery = sqlQueryObject.createSQLQuery();
  530.             stm=con.prepareStatement(sqlQuery);
  531.             stm.setString(1, nomePorta);

  533.             rs=stm.executeQuery();

  535.             if(rs.next())
  536.             {
  537.                 idPortaDelegata=rs.getLong("id");
  538.             }
  539.             return idPortaDelegata;
  540.         }catch (Exception e) {
  541.             throw new CoreException(e);
  542.         }finally
  543.         {
  544.             //Chiudo statement and resultset
  545.             JDBCUtilities.closeResources(rs, stm);

  547.         }

  549.     }
  550.     
  551.     
  552.     
  553.     
  554.     
  555.     
  556.     public static long getIdServizioApplicativo(String nomeServizioApplicativo, String tipoProprietario, String nomeProprietario,
  557.             Connection con, String tipoDB) throws CoreException
  558.     {
  559.         return DBUtils.getIdServizioApplicativo(nomeServizioApplicativo, tipoProprietario, nomeProprietario, con, tipoDB, CostantiDB.SOGGETTI);
  560.     }
  561.     public static long getIdServizioApplicativo(String nomeServizioApplicativo, String tipoProprietario, String nomeProprietario,
  562.             Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  563.     {
  564.         PreparedStatement stm = null;
  565.         ResultSet rs = null;
  566.         long idSoggetto;
  567.         long idServizioApplicativo=-1;

  569.         try
  570.         {
  571.             idSoggetto = DBUtils.getIdSoggetto(nomeProprietario, tipoProprietario, con, tipoDB,tabellaSoggetti);

  573.             //recupero l'id della porta applicativa appena inserita
  574.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  575.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  576.             sqlQueryObject.addSelectField("id");
  577.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  578.             sqlQueryObject.addWhereCondition("nome = ?");
  579.             sqlQueryObject.setANDLogicOperator(true);
  580.             String sqlQuery = sqlQueryObject.createSQLQuery();
  581.             stm=con.prepareStatement(sqlQuery);
  582.             stm.setLong(1, idSoggetto);
  583.             stm.setString(2, nomeServizioApplicativo);

  585.             rs=stm.executeQuery();

  587.             if(rs.next())
  588.             {
  589.                 idServizioApplicativo=rs.getLong("id");
  590.             }
  591.             return idServizioApplicativo;
  592.         }catch (Exception e) {
  593.             throw new CoreException(e);
  594.         }finally
  595.         {
  596.             //Chiudo statement and resultset
  597.             JDBCUtilities.closeResources(rs, stm);

  599.         }

  601.     }

  603.     
  604.     
  605.     
  606.     
  607.     
  608.     public static long getIdPortaDominio(String nome, Connection con, String tipoDB) throws CoreException
  609.     {
  610.         PreparedStatement stm = null;
  611.         ResultSet rs = null;
  612.         long idPdD=-1;
  613.         try
  614.         {
  615.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  616.             sqlQueryObject.addFromTable(CostantiDB.PDD);
  617.             sqlQueryObject.addSelectField("*");
  618.             sqlQueryObject.addWhereCondition("nome = ?");
  619.             sqlQueryObject.setANDLogicOperator(true);
  620.             String query = sqlQueryObject.createSQLQuery();
  621.             stm=con.prepareStatement(query);
  622.             stm.setString(1, nome);

  624.             rs=stm.executeQuery();

  626.             if(rs.next()){
  627.                 idPdD = rs.getLong("id");
  628.             }

  630.             return idPdD;

  632.         }catch (Exception e) {
  633.             throw new CoreException(e);
  634.         }finally
  635.         {
  636.             //Chiudo statement and resultset
  637.             JDBCUtilities.closeResources(rs, stm);

  639.         }
  640.     }
  641.     
  642.     
  643.     
  644.     
  645.     
  646.     public static long getIdGruppo(IDGruppo idGruppo, Connection con, String tipoDB) throws CoreException
  647.     {
  648.         PreparedStatement stm = null;
  649.         ResultSet rs = null;
  650.         long idGruppoLong=-1;
  651.         try
  652.         {
  653.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  654.             sqlQueryObject.addFromTable(CostantiDB.GRUPPI);
  655.             sqlQueryObject.addSelectField("*");
  656.             sqlQueryObject.addWhereCondition("nome = ?");
  657.             sqlQueryObject.setANDLogicOperator(true);
  658.             String query = sqlQueryObject.createSQLQuery();
  659.             stm=con.prepareStatement(query);
  660.             stm.setString(1, idGruppo.getNome());

  662.             rs=stm.executeQuery();

  664.             if(rs.next()){
  665.                 idGruppoLong = rs.getLong("id");
  666.             }

  668.             return idGruppoLong;

  670.         }catch (Exception e) {
  671.             throw new CoreException(e);
  672.         }finally
  673.         {
  674.             //Chiudo statement and resultset
  675.             JDBCUtilities.closeResources(rs, stm);

  677.         }
  678.     }
  679.     
  680.     
  681.     
  682.     
  683.     
  684.     
  685.     public static long getIdRuolo(IDRuolo idRuolo, Connection con, String tipoDB) throws CoreException
  686.     {
  687.         PreparedStatement stm = null;
  688.         ResultSet rs = null;
  689.         long idRuoloLong=-1;
  690.         try
  691.         {
  692.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  693.             sqlQueryObject.addFromTable(CostantiDB.RUOLI);
  694.             sqlQueryObject.addSelectField("*");
  695.             sqlQueryObject.addWhereCondition("nome = ?");
  696.             sqlQueryObject.setANDLogicOperator(true);
  697.             String query = sqlQueryObject.createSQLQuery();
  698.             stm=con.prepareStatement(query);
  699.             stm.setString(1, idRuolo.getNome());

  701.             rs=stm.executeQuery();

  703.             if(rs.next()){
  704.                 idRuoloLong = rs.getLong("id");
  705.             }

  707.             return idRuoloLong;

  709.         }catch (Exception e) {
  710.             throw new CoreException(e);
  711.         }finally
  712.         {
  713.             //Chiudo statement and resultset
  714.             JDBCUtilities.closeResources(rs, stm);

  716.         }
  717.     }
  718.     
  719.     
  720.     
  721.     
  722.     public static long getIdScope(IDScope idScope, Connection con, String tipoDB) throws CoreException
  723.     {
  724.         PreparedStatement stm = null;
  725.         ResultSet rs = null;
  726.         long idScopeLong=-1;
  727.         try
  728.         {
  729.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  730.             sqlQueryObject.addFromTable(CostantiDB.SCOPE);
  731.             sqlQueryObject.addSelectField("*");
  732.             sqlQueryObject.addWhereCondition("nome = ?");
  733.             sqlQueryObject.setANDLogicOperator(true);
  734.             String query = sqlQueryObject.createSQLQuery();
  735.             stm=con.prepareStatement(query);
  736.             stm.setString(1, idScope.getNome());

  738.             rs=stm.executeQuery();

  740.             if(rs.next()){
  741.                 idScopeLong = rs.getLong("id");
  742.             }

  744.             return idScopeLong;

  746.         }catch (Exception e) {
  747.             throw new CoreException(e);
  748.         }finally
  749.         {
  750.             //Chiudo statement and resultset
  751.             JDBCUtilities.closeResources(rs, stm);

  753.         }
  754.     }
  755.     
  756.     
  757.     
  758.     
  759.     

  761.     public static long getIdAccordoServizioParteComune(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,Connection con, String tipoDB) throws CoreException
  762.     {
  763.         return DBUtils.getIdAccordoServizioParteComune(nomeServizio,tipoServizio,versioneServizio, nomeSoggettoErogatore,tipoSoggettoErogatore,con,tipoDB,CostantiDB.SOGGETTI);
  764.     }
  765.     public static long getIdAccordoServizioParteComune(String nomeServizio, String tipoServizio,Integer versioneServizio, String nomeSoggettoErogatore,String tipoSoggettoErogatore,Connection con, String tipoDB,String tabellaSoggetti) throws CoreException
  766.     {
  767.         PreparedStatement stm = null;
  768.         ResultSet rs = null;
  769.         long idServizio;
  770.         long idAccordo = -1;
  771.         try
  772.         {
  773.             idServizio = DBUtils.getIdServizio(nomeServizio, tipoServizio, versioneServizio, nomeSoggettoErogatore, tipoSoggettoErogatore, con, tipoDB,tabellaSoggetti);

  775.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  776.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  777.             sqlQueryObject.addSelectField("*");
  778.             sqlQueryObject.addWhereCondition(WHERE_ID_CONDITION);
  779.             String query = sqlQueryObject.createSQLQuery();
  780.             stm=con.prepareStatement(query);
  781.             stm.setLong(1, idServizio);

  783.             rs=stm.executeQuery();

  785.             if(rs.next()){
  786.                 idAccordo = rs.getLong("id_accordo");
  787.             }

  789.             return idAccordo;

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

  798.         }
  799.     }
  800.     
  801.     public static long getIdPortType(Long idAccordo,String nomePortType,Connection con) throws CoreException{
  802.         PreparedStatement selectStmt = null;
  803.         ResultSet selectRS = null;
  804.         long id=-1;
  805.         try
  806.         {
  807.             String selectQuery = "SELECT id FROM " + CostantiDB.PORT_TYPE + " WHERE id_accordo = ? AND nome=?";
  808.             selectStmt = con.prepareStatement(selectQuery);
  809.             selectStmt.setLong(1, idAccordo);
  810.             selectStmt.setString(2, nomePortType);
  811.             selectRS = selectStmt.executeQuery();
  812.             if (selectRS.next()) {
  813.                 id = selectRS.getLong("id");    
  814.             }
  815.             selectRS.close();
  816.             selectStmt.close();
  817.             return id;
  818.         }catch (Exception e) {
  819.             throw new CoreException(e);
  820.         }finally
  821.         {
  822.             //Chiudo statement and resultset
  823.             JDBCUtilities.closeResources(selectRS, selectStmt);

  825.         }
  826.     }
  827.     
  828.     public static long getIdResource(Long idAccordo,String nomeRisorsa,Connection con) throws CoreException{
  829.         PreparedStatement selectStmt = null;
  830.         ResultSet selectRS = null;
  831.         long id=-1;
  832.         try
  833.         {
  834.             String selectQuery = "SELECT id FROM " + CostantiDB.API_RESOURCES + " WHERE id_accordo = ? AND nome=?";
  835.             selectStmt = con.prepareStatement(selectQuery);
  836.             selectStmt.setLong(1, idAccordo);
  837.             selectStmt.setString(2, nomeRisorsa);
  838.             selectRS = selectStmt.executeQuery();
  839.             if (selectRS.next()) {
  840.                 id = selectRS.getLong("id");    
  841.             }
  842.             selectRS.close();
  843.             selectStmt.close();
  844.             return id;
  845.         }catch (Exception e) {
  846.             throw new CoreException(e);
  847.         }finally
  848.         {
  849.             //Chiudo statement and resultset
  850.             JDBCUtilities.closeResources(selectRS, selectStmt);

  852.         }
  853.     }
  854.     
  855.     public static long getIdAccordoServizioParteComune(IDAccordo idAccordo,Connection con, String tipoDB) throws CoreException{
  856.         PreparedStatement stm = null;
  857.         ResultSet rs = null;
  858.         long idAccordoLong=-1;
  859.         try
  860.         {
  861.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  862.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  863.             sqlQueryObject.addSelectField("*");
  864.             sqlQueryObject.addWhereCondition("nome = ?");
  865.             sqlQueryObject.addWhereCondition("id_referente = ?");
  866.             sqlQueryObject.addWhereCondition("versione = ?");
  867.             sqlQueryObject.setANDLogicOperator(true);
  868.             String query = sqlQueryObject.createSQLQuery();
  869.             stm=con.prepareStatement(query);
  870.             stm.setString(1, idAccordo.getNome());
  871.             
  872.             long idSoggettoReferente =  0;
  873.             if(idAccordo.getSoggettoReferente()!=null){
  874.                 idSoggettoReferente = DBUtils.getIdSoggetto(idAccordo.getSoggettoReferente().getNome(), idAccordo.getSoggettoReferente().getTipo(), con, tipoDB);
  875.                 if(idSoggettoReferente<=0){
  876.                     throw new CoreException("[getIdAccordoServizioParteComune] Soggetto Referente ["+idAccordo.getSoggettoReferente().toString()+"] non esiste");
  877.                 }
  878.             }
  879.             stm.setLong(2, idSoggettoReferente);
  880.                 
  881.             stm.setInt(3, idAccordo.getVersione());
  882.                         
  883.             rs=stm.executeQuery();

  885.             if(rs.next()){
  886.                 idAccordoLong = rs.getLong("id");
  887.             }

  889.             return idAccordoLong;

  891.         }catch (Exception e) {
  892.             throw new CoreException(e);
  893.         }finally
  894.         {
  895.             //Chiudo statement and resultset
  896.             JDBCUtilities.closeResources(rs, stm);

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

  929.             if(rs.next()){
  930.                 int versione = rs.getInt("versione");
  931.                 if(versione>0) {
  932.                     return versione+1;
  933.                 }
  934.             }

  936.             return 1; // accordo non esistente

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

  945.         }
  946.     }
  947.     
  948.     
  949.     
  950.     
  951.     public static long getIdAccordoCooperazione(IDAccordoCooperazione idAccordo,Connection con, String tipoDB) throws CoreException{
  952.         PreparedStatement stm = null;
  953.         ResultSet rs = null;
  954.         long idAccordoLong=-1;
  955.         try
  956.         {
  957.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  958.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_COOPERAZIONE);
  959.             sqlQueryObject.addSelectField("*");
  960.             sqlQueryObject.addWhereCondition("nome = ?");
  961.             sqlQueryObject.addWhereCondition("id_referente = ?");
  962.             sqlQueryObject.addWhereCondition("versione = ?");
  963.             sqlQueryObject.setANDLogicOperator(true);
  964.             String query = sqlQueryObject.createSQLQuery();
  965.             stm=con.prepareStatement(query);
  966.             stm.setString(1, idAccordo.getNome());
  967.                 
  968.             long idSoggettoReferente =  0;
  969.             if(idAccordo.getSoggettoReferente()!=null){
  970.                 idSoggettoReferente = DBUtils.getIdSoggetto(idAccordo.getSoggettoReferente().getNome(), idAccordo.getSoggettoReferente().getTipo(), con, tipoDB);
  971.                 if(idSoggettoReferente<=0){
  972.                     throw new CoreException("[getIdAccordoCooperazione] Soggetto Referente ["+idAccordo.getSoggettoReferente().toString()+"] non esiste");
  973.                 }
  974.             }
  975.             stm.setLong(2, idSoggettoReferente);
  976.                 
  977.             stm.setInt(3, idAccordo.getVersione());
  978.                         
  979.             rs=stm.executeQuery();

  981.             if(rs.next()){
  982.                 idAccordoLong = rs.getLong("id");
  983.             }

  985.             return idAccordoLong;

  987.         }catch (Exception e) {
  988.             throw new CoreException(e);
  989.         }finally
  990.         {
  991.             //Chiudo statement and resultset
  992.             JDBCUtilities.closeResources(rs, stm);

  994.         }
  995.     }
  996.     
  997.     
  998.     public static long getIdAccordoServizioParteSpecifica(IDServizio idServizio,Connection con, String tipoDB) throws CoreException{
  999.         PreparedStatement stm = null;
  1000.         ResultSet rs = null;
  1001.         long idAccordoLong=-1;
  1002.         try
  1003.         {
  1004.             
  1005.             // NOTA: nell'APS, il soggetto e la versione sono obbligatori
  1006.             
  1007.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1008.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1009.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1010.             sqlQueryObject.addSelectField("*");
  1011.             sqlQueryObject.setANDLogicOperator(true);
  1012.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  1013.             sqlQueryObject.addWhereCondition("tipo_soggetto = ?");
  1014.             sqlQueryObject.addWhereCondition("nome_soggetto = ?");
  1015.             sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  1016.             sqlQueryObject.addWhereCondition("nome_servizio = ?");
  1017.             sqlQueryObject.addWhereCondition("versione_servizio = ?");
  1018.             String query = sqlQueryObject.createSQLQuery();
  1019.             stm=con.prepareStatement(query);
  1020.             stm.setString(1, idServizio.getSoggettoErogatore().getTipo());
  1021.             stm.setString(2, idServizio.getSoggettoErogatore().getNome());
  1022.             stm.setString(3, idServizio.getTipo());
  1023.             stm.setString(4, idServizio.getNome());
  1024.             stm.setInt(5, idServizio.getVersione());
  1025.             
  1026.             rs=stm.executeQuery();

  1028.             if(rs.next()){
  1029.                 idAccordoLong = rs.getLong("id");
  1030.             }

  1032.             return idAccordoLong;

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

  1041.         }
  1042.     }
  1043.     
  1044.     
  1045.     public static long getIdFruizioneServizio(IDServizio idServizio,IDSoggetto idFruitore, Connection con, String tipoDB) throws CoreException{
  1046.         return getIdFruizioneServizio(idServizio, idFruitore, con, tipoDB, CostantiDB.SOGGETTI);
  1047.     }
  1048.     public static long getIdFruizioneServizio(IDServizio idServizio,IDSoggetto idFruitore, Connection con, String tipoDB, String tabellaSoggetti) throws CoreException{
  1049.         return _getIdFruizioneServizio(DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB), idFruitore, con, tipoDB, tabellaSoggetti);
  1050.     }
  1051.     
  1052.     private static long _getIdFruizioneServizio(long idServizio,IDSoggetto idFruitore, Connection con, String tipoDB, String tabellaSoggetti) throws CoreException{
  1053.         PreparedStatement stm = null;
  1054.         ResultSet rs = null;
  1055.         long idFruizione=-1;
  1056.         try
  1057.         {
  1058.             
  1059.             // NOTA: nell'APS, il soggetto e la versione sono obbligatori
  1060.             
  1061.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1062.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  1063.             sqlQueryObject.addSelectField("id");
  1064.             sqlQueryObject.setANDLogicOperator(true);
  1065.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_servizio = ?");
  1066.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_soggetto = ?");
  1067.             String query = sqlQueryObject.createSQLQuery();
  1068.             stm=con.prepareStatement(query);
  1069.             stm.setLong(1, idServizio);
  1070.             stm.setLong(2, DBUtils.getIdSoggetto(idFruitore.getNome(), idFruitore.getTipo(), con, tipoDB,tabellaSoggetti));
  1071.             
  1072.             rs=stm.executeQuery();

  1074.             if(rs.next()){
  1075.                 idFruizione = rs.getLong("id");
  1076.             }

  1078.             return idFruizione;

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

  1087.         }
  1088.     }
  1089.     

  1091.     public static long getIdDocumento(String nome, String tipo, String ruolo, long idProprietario,Connection con,String tipoDB,String tipoProprietario) throws CoreException{
  1092.         PreparedStatement stm = null;
  1093.         ResultSet rs = null;
  1094.         long idDoc=-1;
  1095.         try
  1096.         {
  1097.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1098.             sqlQueryObject.addFromTable(CostantiDB.DOCUMENTI);
  1099.             sqlQueryObject.addSelectField("id");
  1100.             sqlQueryObject.addWhereCondition("id_proprietario = ?");
  1101.             sqlQueryObject.addWhereCondition("nome = ?");
  1102.             if(tipo!=null) {
  1103.                 sqlQueryObject.addWhereCondition("tipo = ?");
  1104.             }
  1105.             if(ruolo!=null) {
  1106.                 sqlQueryObject.addWhereCondition("ruolo = ?");
  1107.             }
  1108.             sqlQueryObject.addWhereCondition("tipo_proprietario = ?");
  1109.             sqlQueryObject.setANDLogicOperator(true);
  1110.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1111.             stm = con.prepareStatement(sqlQuery);
  1112.             int index = 1;
  1113.             stm.setLong(index++, idProprietario);
  1114.             stm.setString(index++, nome);
  1115.             if(tipo!=null) {
  1116.                 stm.setString(index++, tipo);
  1117.             }
  1118.             if(ruolo!=null) {
  1119.                 stm.setString(index++, ruolo);
  1120.             }
  1121.             stm.setString(index++, tipoProprietario);
  1122.             rs = stm.executeQuery();
  1123.             if (rs.next())
  1124.                 idDoc = rs.getLong("id");
  1125.             rs.close();
  1126.             stm.close();

  1128.             return idDoc;
  1129.         }catch (Exception e) {
  1130.             throw new CoreException(e);
  1131.         }finally
  1132.         {
  1133.             //Chiudo statement and resultset
  1134.             JDBCUtilities.closeResources(rs, stm);

  1136.         }
  1137.     }
  1138.     
  1139.     
  1140.     public static long getIdProtocolProperty(String tipoProprietario, long idProprietario,String nome, Connection con,String tipoDB) throws CoreException{
  1141.         PreparedStatement stm = null;
  1142.         ResultSet rs = null;
  1143.         long idPP=-1;
  1144.         try
  1145.         {
  1146.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1147.             sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  1148.             sqlQueryObject.addSelectField("id");
  1149.             sqlQueryObject.addWhereCondition("tipo_proprietario = ?");
  1150.             sqlQueryObject.addWhereCondition("id_proprietario = ?");
  1151.             sqlQueryObject.addWhereCondition("name = ?");
  1152.             sqlQueryObject.setANDLogicOperator(true);
  1153.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1154.             stm = con.prepareStatement(sqlQuery);
  1155.             stm.setString(1, tipoProprietario);
  1156.             stm.setLong(2, idProprietario);
  1157.             stm.setString(3, nome);
  1158.             rs = stm.executeQuery();
  1159.             if (rs.next())
  1160.                 idPP = rs.getLong("id");
  1161.             rs.close();
  1162.             stm.close();

  1164.             return idPP;
  1165.         }catch (Exception e) {
  1166.             throw new CoreException(e);
  1167.         }finally
  1168.         {
  1169.             //Chiudo statement and resultset
  1170.             JDBCUtilities.closeResources(rs, stm);

  1172.         }
  1173.     }
  1174.     
  1175.     
  1176.     
  1177.     
  1178.     
  1179.     public static long getIdRegistroPlugin(String nome, Connection con,String tipoDB) throws CoreException{
  1180.         PreparedStatement stm = null;
  1181.         ResultSet rs = null;
  1182.         long idRP=-1;
  1183.         try
  1184.         {
  1185.             if(nome==null) {
  1186.                 throw new CoreException("Nome non fornito");
  1187.             }
  1188.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1189.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  1190.             sqlQueryObject.addSelectField("id");
  1191.             sqlQueryObject.addWhereCondition("nome=?");
  1192.             sqlQueryObject.setANDLogicOperator(true);
  1193.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1194.             stm = con.prepareStatement(sqlQuery);
  1195.             stm.setString(1, nome);
  1196.             rs = stm.executeQuery();
  1197.             if(rs.next()) {
  1198.                 idRP = rs.getLong("id");
  1199.             }
  1200.             rs.close();
  1201.             stm.close();
  1202.             rs=null;
  1203.             stm=null;
  1204.             
  1205.             return idRP;
  1206.         }catch (Exception e) {
  1207.             throw new CoreException(e);
  1208.         }finally
  1209.         {
  1210.             //Chiudo statement and resultset
  1211.             JDBCUtilities.closeResources(rs, stm);

  1213.         }
  1214.     }
  1215.     
  1216.     
  1217.     public static long getIdPlugin(String className, String label, String tipoPlugin, String tipo, Connection con,String tipoDB) throws CoreException{
  1218.         PreparedStatement stm = null;
  1219.         ResultSet rs = null;
  1220.         long idRP=-1;
  1221.         try
  1222.         {
  1223.             if(className==null) {
  1224.                 throw new CoreException("ClassName non fornito");
  1225.             }
  1226.             if(label==null) {
  1227.                 throw new CoreException("Label non fornito");
  1228.             }
  1229.             if(tipoPlugin==null) {
  1230.                 throw new CoreException("TipoPlugin non fornito");
  1231.             }
  1232.             if(tipo==null) {
  1233.                 throw new CoreException("Tipo non fornito");
  1234.             }
  1235.             
  1236.             
  1237.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1238.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_CLASSI);
  1239.             sqlQueryObject.addSelectField("id");
  1240.             sqlQueryObject.addWhereCondition("class_name=?");
  1241.             sqlQueryObject.addWhereCondition("label=?");
  1242.             sqlQueryObject.addWhereCondition("tipo_plugin=?");
  1243.             sqlQueryObject.addWhereCondition("tipo=?");
  1244.             sqlQueryObject.setANDLogicOperator(true);
  1245.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1246.             stm = con.prepareStatement(sqlQuery);
  1247.             stm.setString(1, className);
  1248.             stm.setString(2, label);
  1249.             stm.setString(3, tipoPlugin);
  1250.             stm.setString(4, tipo);
  1251.             rs = stm.executeQuery();
  1252.             if(rs.next()) {
  1253.                 idRP = rs.getLong("id");
  1254.             }
  1255.             rs.close();
  1256.             stm.close();
  1257.             rs=null;
  1258.             stm=null;
  1259.             
  1260.             return idRP;
  1261.         }catch (Exception e) {
  1262.             throw new CoreException(e);
  1263.         }finally
  1264.         {
  1265.             //Chiudo statement and resultset
  1266.             JDBCUtilities.closeResources(rs, stm);

  1268.         }
  1269.     }
  1270.     
  1271.     
  1272.     public static long getUrlInvocazioneRegola(String nome, Connection con,String tipoDB) throws CoreException{
  1273.         PreparedStatement stm = null;
  1274.         ResultSet rs = null;
  1275.         long idRP=-1;
  1276.         try
  1277.         {
  1278.             if(nome==null) {
  1279.                 throw new CoreException("Nome non fornito");
  1280.             }
  1281.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1282.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  1283.             sqlQueryObject.addSelectField("id");
  1284.             sqlQueryObject.addWhereCondition("nome=?");
  1285.             sqlQueryObject.setANDLogicOperator(true);
  1286.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1287.             stm = con.prepareStatement(sqlQuery);
  1288.             stm.setString(1, nome);
  1289.             rs = stm.executeQuery();
  1290.             if(rs.next()) {
  1291.                 idRP = rs.getLong("id");
  1292.             }
  1293.             rs.close();
  1294.             stm.close();
  1295.             rs=null;
  1296.             stm=null;
  1297.             
  1298.             return idRP;
  1299.         }catch (Exception e) {
  1300.             throw new CoreException(e);
  1301.         }finally
  1302.         {
  1303.             //Chiudo statement and resultset
  1304.             JDBCUtilities.closeResources(rs, stm);

  1306.         }
  1307.     }
  1308.     
  1309.     

  1311.     public static void setPropertiesForSearch(ISQLQueryObject sqlQueryObject, Map<String, String> properties, String tabellaPadre, 
  1312.             String tabellaProprieta, String columnName, String columnValue, String columnFK) throws SQLQueryObjectException{
  1313.         if(properties!=null && properties.size()>0){
  1314.             String [] conditions = new String[properties.size()];
  1315.             int i = 0;
  1316.             for (String nome : properties.keySet()) {

  1318.                 String aliasTabella = "pp"+i+tabellaPadre;
  1319.                 sqlQueryObject.addFromTable(tabellaProprieta, aliasTabella);
  1320.                 sqlQueryObject.setANDLogicOperator(true);
  1321.                 sqlQueryObject.addWhereCondition(aliasTabella+"."+columnFK+"="+tabellaPadre+".id");
  1322.                 String valore = properties.get(nome);
  1323.                                 
  1324.                 if(conditions[i]!=null){
  1325.                     conditions[i] = conditions[i] + " AND ";
  1326.                 }
  1327.                 else {
  1328.                     conditions[i] = "";
  1329.                 }
  1330.                 conditions[i] = conditions[i] + " " + aliasTabella+"."+columnName+"=?";
  1331.                 
  1332.                 if(valore!=null){
  1333.                     if(conditions[i]!=null){
  1334.                         conditions[i] = conditions[i] + " AND ";
  1335.                     }
  1336.                     else {
  1337.                         conditions[i] = "";
  1338.                     }
  1339.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+columnValue+"=?";
  1340.                 }
  1341.                 else {
  1342.                     if(conditions[i]!=null){
  1343.                         conditions[i] = conditions[i] + " AND ";
  1344.                     }
  1345.                     else {
  1346.                         conditions[i] = "";
  1347.                     }
  1348.                     conditions[i] = conditions[i] + " " + aliasTabella+"."+columnValue+" is null";
  1349.                 }
  1350.                 
  1351.                 // casoSpecialeValoreNull
  1352.                 ISQLQueryObject sqlQueryObjectPropertyNotExists = null;
  1353.                 // in un caso dove il valore non e' definito nel database ci possono essere due casistiche:
  1354.                 // 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)
  1355.                 // 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.
  1356.                 if(valore==null){
  1357.                     
  1358.                     ISQLQueryObject sqlQueryObjectPropertyNotExistsInternal = sqlQueryObject.newSQLQueryObject();
  1359.                     String aliasTabellaNotExists =  "not_exists_"+aliasTabella;
  1360.                     sqlQueryObjectPropertyNotExistsInternal.addFromTable(tabellaProprieta, aliasTabellaNotExists);
  1361.                     sqlQueryObjectPropertyNotExistsInternal.addSelectField(aliasTabellaNotExists, "id");
  1362.                     sqlQueryObjectPropertyNotExistsInternal.addWhereCondition(aliasTabellaNotExists+"."+columnFK+"="+aliasTabella+"."+columnFK);
  1363.                     sqlQueryObjectPropertyNotExistsInternal.addWhereCondition(aliasTabellaNotExists+"."+columnName+"=?");
  1364.                     sqlQueryObjectPropertyNotExistsInternal.setANDLogicOperator(true);
  1365.                     
  1366.                     sqlQueryObjectPropertyNotExists = sqlQueryObject.newSQLQueryObject();
  1367.                     sqlQueryObjectPropertyNotExists.addWhereExistsCondition(true, sqlQueryObjectPropertyNotExistsInternal);

  1369.                     conditions[i] = "( " + conditions[i] + " ) OR ( " + sqlQueryObjectPropertyNotExists.createSQLConditions() + " )";
  1370.                 }
  1371.                 i++;
  1372.             }
  1373.             sqlQueryObject.addWhereCondition(true, conditions);
  1374.         }
  1375.     }
  1376.     
  1377.     public static void setPropertiesForSearch(PreparedStatement stmt, int index, 
  1378.             Map<String, String> properties,
  1379.             String tipoDatabase, Logger log) throws SQLQueryObjectException, SQLException, JDBCAdapterException, UtilsException{
  1380.         
  1381.         GenericJDBCParameterUtilities jdbcParameterUtilities = new GenericJDBCParameterUtilities(TipiDatabase.toEnumConstant(tipoDatabase));
  1382.         
  1383.         if(properties!=null && properties.size()>0){
  1384.             int i = 0;
  1385.             for (String nome : properties.keySet()) {
  1386.                 
  1387.                 String valore = properties.get(nome);
  1388.                 
  1389.                 log.debug("Proprieta["+i+"] nome stmt.setString("+nome+")");
  1390.                 stmt.setString(index++, nome);
  1391.                                 
  1392.                 if(valore!=null){
  1393.                     log.debug("Proprieta["+i+"] valore stmt.setString("+valore+")");
  1394.                     jdbcParameterUtilities.setParameter(stmt, index++, valore, String.class);
  1395.                 }
  1396.                 
  1397.                 // casoSpecialeValoreNull
  1398.                 // in un caso dove il valore non e' definito nel database ci possono essere due casistiche:
  1399.                 // 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)
  1400.                 // 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.
  1401.                 if(valore==null){
  1402.                     log.debug("Proprieta["+i+"] nome stmt.setString("+nome+")");
  1403.                     stmt.setString(index++, nome);
  1404.                 }
  1405.                 
  1406.                 i++;
  1407.             }
  1408.         }
  1409.     }


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

  1416.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1417.         sql.addFromTable(CostantiDB.CONNETTORI);
  1418.         sql.setANDLogicOperator(true);
  1419.         sql.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_connettore_inv="+CostantiDB.CONNETTORI+".id");
  1420.         setFiltriConnettore(sql, tipoDB,
  1421.                 tipoConnettore, endpointType, tipoConnettoreIntegrationManager,
  1422.                 filtroConnettoreTokenPolicy, filtroConnettoreEndpoint, filtroConnettoreKeystore, filtroConnettoreDebug,
  1423.                 CostantiDB.SERVIZI_APPLICATIVI);
  1424.         sqlQueryObject.addWhereExistsCondition(false, sql);
  1425.         
  1426.     }
  1427.     public static void setFiltriConnettoreErogazione(ISQLQueryObject sqlQueryObject, String tipoDB,
  1428.             TipiConnettore tipoConnettore, String endpointType, boolean tipoConnettoreIntegrationManager,
  1429.             String filtroConnettoreTokenPolicy, String filtroConnettoreEndpoint, String filtroConnettoreKeystore, String filtroConnettoreDebug) throws Exception {

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

  1867.             query = new ArrayList<>();
  1868.             
  1869.             ISQLQueryObject sqlAccordoSecPattern = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_COMUNE, CostantiDB.ACCORDI,
  1870.                     tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN, filtroModIInfoUtente, null, null);
  1871.             query.add(sqlQueryObject.getWhereExistsCondition(false, sqlAccordoSecPattern));
  1872.             
  1873.             addRestCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN, filtroModIInfoUtente, null);
  1874.             
  1875.             addSoapCondition(query, sqlQueryObject, tipoDB, CostantiDB.MODIPA_PROFILO_SICUREZZA_MESSAGGIO_CORNICE_SICUREZZA_PATTERN, filtroModIInfoUtente, null);
  1876.             
  1877.             if(!query.isEmpty()) {
  1878.                 sqlQueryObject.addWhereCondition(false, query.toArray(new String[1]));
  1879.             }
  1880.             
  1881.         }
  1882.                 
  1883.     }
  1884.     private static void addRestCondition(List<String> query, ISQLQueryObject sqlQueryObject, String tipoDB, String nomeProprieta, String valoreProprieta, Boolean valoreProprietaBoolean) throws Exception {
  1885.         String aliasRISORSE = "m_res";
  1886.         ISQLQueryObject sqlREST = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1887.         sqlREST.addFromTable(CostantiDB.API_RESOURCES, aliasRISORSE);
  1888.         sqlREST.setANDLogicOperator(true);
  1889.         sqlREST.addWhereCondition(aliasRISORSE+".id_accordo="+CostantiDB.ACCORDI+".id");
  1890.         ISQLQueryObject sqlRestSec = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.RESOURCE, aliasRISORSE,
  1891.                 tipoDB, nomeProprieta, valoreProprieta, null, valoreProprietaBoolean);
  1892.         sqlREST.addWhereExistsCondition(false, sqlRestSec);
  1893.         query.add(sqlQueryObject.getWhereExistsCondition(false, sqlREST));
  1894.     }
  1895.     private static void addSoapCondition(List<String> query, ISQLQueryObject sqlQueryObject, String tipoDB, String nomeProprieta, String valoreProprieta, Boolean valoreProprietaBoolean) throws Exception {
  1896.         String aliasPORTTYPES = "m_pt";
  1897.         String aliasOPERATIONS = "m_op";
  1898.         ISQLQueryObject sqlSOAP = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1899.         sqlSOAP.addFromTable(CostantiDB.PORT_TYPE, aliasPORTTYPES);
  1900.         sqlSOAP.addFromTable(CostantiDB.PORT_TYPE_AZIONI, aliasOPERATIONS);
  1901.         sqlSOAP.setANDLogicOperator(true);
  1902.         sqlSOAP.addWhereCondition(aliasPORTTYPES+".id_accordo="+CostantiDB.ACCORDI+".id");
  1903.         sqlSOAP.addWhereCondition(aliasOPERATIONS+".id_port_type="+aliasPORTTYPES+".id");
  1904.         ISQLQueryObject sqlSoapSec = buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty.OPERATION, aliasOPERATIONS,
  1905.                 tipoDB, nomeProprieta, valoreProprieta, null, valoreProprietaBoolean);
  1906.         sqlSOAP.addWhereExistsCondition(false, sqlSoapSec);
  1907.         query.add(sqlQueryObject.getWhereExistsCondition(false, sqlSOAP));
  1908.     }
  1909.     private static ISQLQueryObject buildSQLQueryObjectProtocolProperties(ProprietariProtocolProperty tipoProprietario, String tabellaProprietario,
  1910.             String tipoDB, String nomeProprieta, String valoreProprietaEquals, String valoreProprietaContains, Boolean valoreProprietaBoolean) throws Exception {
  1911.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1912.         sql.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  1913.         sql.setANDLogicOperator(true);
  1914.         sql.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES+".id_proprietario="+tabellaProprietario+".id");
  1915.         sql.addWhereLikeCondition(CostantiDB.PROTOCOL_PROPERTIES+".tipo_proprietario", tipoProprietario.name(), false, false, false);
  1916.         sql.addWhereLikeCondition(CostantiDB.PROTOCOL_PROPERTIES+".name", nomeProprieta, false, false, false);
  1917.         if(valoreProprietaContains!=null) {
  1918.             sql.addWhereLikeCondition(CostantiDB.PROTOCOL_PROPERTIES+".value_string", valoreProprietaContains, LikeConfig.contains(true));
  1919.         }
  1920.         else if(valoreProprietaEquals!=null) {
  1921.             sql.addWhereLikeCondition(CostantiDB.PROTOCOL_PROPERTIES+".value_string", valoreProprietaEquals, false, false, false);
  1922.         }
  1923.         if(valoreProprietaBoolean!=null) {
  1924.             if(valoreProprietaBoolean) {
  1925.                 sql.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES+".value_boolean="+CostantiDB.TRUE);
  1926.             }
  1927.             else {
  1928.                 sql.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES+".value_boolean="+CostantiDB.FALSE);
  1929.             }
  1930.         }
  1931.         return sql;
  1932.     }
  1933.     
  1934.     
  1935.     public static void setFiltriProprietaApplicativo(ISQLQueryObject sqlQueryObject, String tipoDB, 
  1936.             String nomeProprieta, String valoreProprieta) throws Exception {
  1937.         setFiltriProprieta(sqlQueryObject, tipoDB, 
  1938.                 ProprietariProtocolProperty.SERVIZIO_APPLICATIVO, null,
  1939.                 nomeProprieta, valoreProprieta);
  1940.     }
  1941.     public static void setFiltriProprietaSoggetto(ISQLQueryObject sqlQueryObject, String tipoDB, 
  1942.             String nomeProprieta, String valoreProprieta) throws Exception {
  1943.         setFiltriProprieta(sqlQueryObject, tipoDB, 
  1944.                 ProprietariProtocolProperty.SOGGETTO, null,
  1945.                 nomeProprieta, valoreProprieta);
  1946.     }
  1947.     public static void setFiltriProprietaErogazione(ISQLQueryObject sqlQueryObject, String tipoDB, 
  1948.             String nomeProprieta, String valoreProprieta) throws Exception {
  1949.         
  1950.         String aliasMAPPING_EROGAZIONE_PA = "c_map";
  1951.         String aliasPORTE_APPLICATIVE = "c_pa";
  1952.         
  1953.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1954.         sql.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA, aliasMAPPING_EROGAZIONE_PA);
  1955.         sql.addFromTable(CostantiDB.PORTE_APPLICATIVE, aliasPORTE_APPLICATIVE);
  1956.         sql.setANDLogicOperator(true);
  1957.         sql.addWhereCondition(aliasMAPPING_EROGAZIONE_PA+".id_erogazione="+CostantiDB.SERVIZI+".id");
  1958.         sql.addWhereCondition(aliasMAPPING_EROGAZIONE_PA+".id_porta="+aliasPORTE_APPLICATIVE+".id");
  1959.         setFiltriProprieta(sql, tipoDB, 
  1960.                 ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA, aliasPORTE_APPLICATIVE,
  1961.                 nomeProprieta, valoreProprieta);
  1962.         sqlQueryObject.addWhereExistsCondition(false, sql);
  1963.         
  1964.     }
  1965.     public static void setFiltriProprietaFruizione(ISQLQueryObject sqlQueryObject, String tipoDB, 
  1966.             String nomeProprieta, String valoreProprieta) throws Exception {
  1967.         
  1968.         String aliasMAPPING_FRUIZIONE_PD = "c_map";
  1969.         String aliasPORTE_DELEGATE = "c_pd";
  1970.         
  1971.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1972.         sql.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD, aliasMAPPING_FRUIZIONE_PD);
  1973.         sql.addFromTable(CostantiDB.PORTE_DELEGATE, aliasPORTE_DELEGATE);
  1974.         sql.setANDLogicOperator(true);
  1975.         sql.addWhereCondition(aliasMAPPING_FRUIZIONE_PD+".id_fruizione="+CostantiDB.SERVIZI_FRUITORI+".id");
  1976.         sql.addWhereCondition(aliasMAPPING_FRUIZIONE_PD+".id_porta="+aliasPORTE_DELEGATE+".id");
  1977.         setFiltriProprieta(sql, tipoDB, 
  1978.                 ProprietariProtocolProperty.FRUITORE, aliasPORTE_DELEGATE,
  1979.                 nomeProprieta, valoreProprieta);
  1980.         sqlQueryObject.addWhereExistsCondition(false, sql);
  1981.         
  1982.     }
  1983.     private static void setFiltriProprieta(ISQLQueryObject sqlQueryObject, String tipoDB, 
  1984.             ProprietariProtocolProperty tipoProprietario, String tabellaAlias,
  1985.             String nomeProprieta, String valoreProprieta) throws Exception {
  1986.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1987.         String nomeTabellaPrincipale = null;
  1988.         String nomeTabellaProprieta = null;
  1989.         String colonnaJoin = null;
  1990.         if(ProprietariProtocolProperty.SERVIZIO_APPLICATIVO.equals(tipoProprietario)) {
  1991.             nomeTabellaPrincipale = CostantiDB.SERVIZI_APPLICATIVI;
  1992.             nomeTabellaProprieta = CostantiDB.SERVIZI_APPLICATIVI_PROPS;
  1993.             colonnaJoin = "id_servizio_applicativo";
  1994.         }
  1995.         else if(ProprietariProtocolProperty.SOGGETTO.equals(tipoProprietario)) {
  1996.             nomeTabellaPrincipale = CostantiDB.SOGGETTI;
  1997.             nomeTabellaProprieta = CostantiDB.SOGGETTI_PROPS;
  1998.             colonnaJoin = "id_soggetto";
  1999.         }
  2000.         else if(ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA.equals(tipoProprietario)) {
  2001.             nomeTabellaPrincipale = tabellaAlias;
  2002.             nomeTabellaProprieta = CostantiDB.PORTE_APPLICATIVE_PROP;
  2003.             colonnaJoin = "id_porta";
  2004.         }
  2005.         else if(ProprietariProtocolProperty.FRUITORE.equals(tipoProprietario)) {
  2006.             nomeTabellaPrincipale = tabellaAlias;
  2007.             nomeTabellaProprieta = CostantiDB.PORTE_DELEGATE_PROP;
  2008.             colonnaJoin = "id_porta";
  2009.         }
  2010.         else {
  2011.             throw new Exception("Tipo proprietario '"+tipoProprietario+"' non gestito");
  2012.         }
  2013.         sql.addFromTable(nomeTabellaProprieta);
  2014.         sql.setANDLogicOperator(true);
  2015.         sql.addWhereCondition(nomeTabellaProprieta+"."+colonnaJoin+"="+nomeTabellaPrincipale+".id");
  2016.         if(nomeProprieta!=null) {
  2017.             sql.addWhereLikeCondition(nomeTabellaProprieta+".nome", nomeProprieta, false, false, false);
  2018.         }
  2019.         if(valoreProprieta!=null) {
  2020.             sql.addWhereLikeCondition(nomeTabellaProprieta+".valore", valoreProprieta, LikeConfig.contains(true));
  2021.         }
  2022.         sqlQueryObject.addWhereExistsCondition(false, sql);
  2023.     }
  2024.     
  2025.     
  2026.     
  2027.     public static void setFiltriConfigurazioneErogazione(ISQLQueryObject sqlQueryObject, String tipoDB,
  2028.             String filtroStatoAPIImpl,
  2029.             String filtroAutenticazioneTokenPolicy,
  2030.             String filtroAutenticazioneTrasporto,
  2031.             String filtroRateLimitingStato,
  2032.             String filtroValidazioneStato,
  2033.             String filtroCacheRispostaStato,
  2034.             String filtroMessageSecurityStato,
  2035.             String filtroMTOMStato,
  2036.             String filtroTrasformazione,
  2037.             String filtroConfigurazioneTransazioni,
  2038.             String filtroCorrelazioneApplicativa,
  2039.             String filtroConfigurazioneDumpTipo,
  2040.             String filtroCORS, String filtroCORSOrigin) throws Exception {
  2041.         _setFiltriConfigurazione(sqlQueryObject, tipoDB,
  2042.                 filtroStatoAPIImpl,
  2043.                 filtroAutenticazioneTokenPolicy,
  2044.                 filtroAutenticazioneTrasporto,
  2045.                 filtroRateLimitingStato,
  2046.                 filtroValidazioneStato,
  2047.                 filtroCacheRispostaStato,
  2048.                 filtroMessageSecurityStato,
  2049.                 filtroMTOMStato,
  2050.                 filtroTrasformazione,
  2051.                 filtroConfigurazioneTransazioni,
  2052.                 filtroCorrelazioneApplicativa,
  2053.                 filtroConfigurazioneDumpTipo,
  2054.                 filtroCORS, filtroCORSOrigin, 
  2055.                 true);
  2056.     }
  2057.     public static void setFiltriConfigurazioneFruizione(ISQLQueryObject sqlQueryObject, String tipoDB,
  2058.             String filtroStatoAPIImpl,
  2059.             String filtroAutenticazioneTokenPolicy,
  2060.             String filtroAutenticazioneTrasporto,
  2061.             String filtroRateLimitingStato,
  2062.             String filtroValidazioneStato,
  2063.             String filtroCacheRispostaStato,
  2064.             String filtroMessageSecurityStato,
  2065.             String filtroMTOMStato,
  2066.             String filtroTrasformazione,
  2067.             String filtroConfigurazioneTransazioni,
  2068.             String filtroCorrelazioneApplicativa,
  2069.             String filtroConfigurazioneDumpTipo,
  2070.             String filtroCORS, String filtroCORSOrigin) throws Exception {
  2071.         _setFiltriConfigurazione(sqlQueryObject, tipoDB,
  2072.                 filtroStatoAPIImpl,
  2073.                 filtroAutenticazioneTokenPolicy,
  2074.                 filtroAutenticazioneTrasporto,
  2075.                 filtroRateLimitingStato,
  2076.                 filtroValidazioneStato,
  2077.                 filtroCacheRispostaStato,
  2078.                 filtroMessageSecurityStato,
  2079.                 filtroMTOMStato,
  2080.                 filtroTrasformazione,
  2081.                 filtroConfigurazioneTransazioni,
  2082.                 filtroCorrelazioneApplicativa,
  2083.                 filtroConfigurazioneDumpTipo,
  2084.                 filtroCORS, filtroCORSOrigin,
  2085.                 false);
  2086.     }
  2087.     public static void _setFiltriConfigurazione(ISQLQueryObject sqlQueryObject, String tipoDB,
  2088.             String filtroStatoAPIImpl,
  2089.             String filtroAutenticazioneTokenPolicy,
  2090.             String filtroAutenticazioneTrasporto,
  2091.             String filtroRateLimitingStato,
  2092.             String filtroValidazioneStato,
  2093.             String filtroCacheRispostaStato,
  2094.             String filtroMessageSecurityStato,
  2095.             String filtroMTOMStato,
  2096.             String filtroTrasformazione,
  2097.             String filtroConfigurazioneTransazioni,
  2098.             String filtroCorrelazioneApplicativa,
  2099.             String filtroConfigurazioneDumpTipo,
  2100.             String filtroCORS, String filtroCORSOrigin,
  2101.             boolean erogazioni) throws Exception {

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

  2356.         if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_DEFAULT.equals(filtroConfigurazioneTransazioni)) {
  2357.             sqlQueryQuery.addWhereCondition(aliasCONFIGPORTA+".tracciamento_stato is NULL OR "+aliasCONFIGPORTA+".tracciamento_stato='"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'");
  2358.         }
  2359.         else {
  2360.             sqlQueryQuery.addWhereCondition(aliasCONFIGPORTA+".tracciamento_stato='"+CostantiDB.STATO_FUNZIONALITA_ABILITATO+"'");
  2361.             
  2362.             String aliasTRANSAZIONICONFIGDB = "trans_cdb";
  2363.             ISQLQueryObject sqlDB = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2364.             sqlDB.addFromTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE, aliasTRANSAZIONICONFIGDB);
  2365.             sqlDB.addSelectField(aliasTRANSAZIONICONFIGDB, CostantiDB.COLUMN_ID_PROPRIETARIO);
  2366.             sqlDB.setANDLogicOperator(true);
  2367.             sqlDB.addWhereCondition(aliasCONFIGPORTA+".id="+aliasTRANSAZIONICONFIGDB+"."+CostantiDB.COLUMN_ID_PROPRIETARIO);
  2368.             sqlDB.addWhereCondition(aliasTRANSAZIONICONFIGDB+".proprietario='"+
  2369.                     (erogazioni ? CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PA : CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD)+"'");    
  2370.             sqlDB.addWhereCondition(aliasTRANSAZIONICONFIGDB+".tipo='"+CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB+"'"); 
  2371.             
  2372.             String aliasTRANSAZIONICONFIGFILETRACE = "trans_cft";
  2373.             ISQLQueryObject sqlFileTrace = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2374.             sqlFileTrace.addFromTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE, aliasTRANSAZIONICONFIGFILETRACE);
  2375.             sqlFileTrace.addSelectField(aliasTRANSAZIONICONFIGFILETRACE, CostantiDB.COLUMN_ID_PROPRIETARIO);
  2376.             sqlFileTrace.setANDLogicOperator(true);
  2377.             sqlFileTrace.addWhereCondition(aliasCONFIGPORTA+".id="+aliasTRANSAZIONICONFIGFILETRACE+"."+CostantiDB.COLUMN_ID_PROPRIETARIO);
  2378.             sqlFileTrace.addWhereCondition(aliasTRANSAZIONICONFIGFILETRACE+".proprietario='"+
  2379.                     (erogazioni ? CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PA : CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD)+"'");    
  2380.             sqlFileTrace.addWhereCondition(aliasTRANSAZIONICONFIGFILETRACE+".tipo='"+CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_FILETRACE+"'");    
  2381.         
  2382.             if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_O_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2383.                     ||
  2384.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_DATABASE.equals(filtroConfigurazioneTransazioni)
  2385.                     ||
  2386.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_E_FILETRACE.equals(filtroConfigurazioneTransazioni)) {
  2387.                 sqlDB.addWhereCondition(aliasTRANSAZIONICONFIGDB+".stato<>'"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'");   
  2388.             }
  2389.             else {
  2390.                 sqlDB.addWhereCondition(aliasTRANSAZIONICONFIGDB+".stato='"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'");    
  2391.             }
  2392.             
  2393.             if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_O_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2394.                 ||
  2395.                 Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2396.                 ||
  2397.                 Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_E_FILETRACE.equals(filtroConfigurazioneTransazioni)) {
  2398.                 sqlFileTrace.addWhereCondition(aliasTRANSAZIONICONFIGFILETRACE+".stato<>'"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'"); 
  2399.             }
  2400.             else {
  2401.                 sqlFileTrace.addWhereCondition(aliasTRANSAZIONICONFIGFILETRACE+".stato='"+CostantiDB.STATO_FUNZIONALITA_DISABILITATO+"'");  
  2402.             }
  2403.             
  2404.             if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_O_FILETRACE.equals(filtroConfigurazioneTransazioni)) {
  2405.                 ISQLQueryObject sqlUtilsDB = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2406.                 ISQLQueryObject sqlUtilsFileTrace = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2407.                 sqlQueryQuery.addWhereCondition(false, 
  2408.                         sqlUtilsDB.getWhereExistsCondition(false, sqlDB),
  2409.                         sqlUtilsFileTrace.getWhereExistsCondition(false, sqlFileTrace));
  2410.             }
  2411.             else if(Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_DATABASE.equals(filtroConfigurazioneTransazioni)
  2412.                     ||
  2413.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_SOLO_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2414.                     ||
  2415.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_ABILITATO_DATABASE_E_FILETRACE.equals(filtroConfigurazioneTransazioni)
  2416.                     ||
  2417.                     Filtri.FILTRO_CONFIGURAZIONE_TRANSAZIONI_VALORE_RIDEFINITO_DISABILITATO.equals(filtroConfigurazioneTransazioni)) {
  2418.                 sqlQueryQuery.addWhereExistsCondition(false, sqlDB);
  2419.                 sqlQueryQuery.addWhereExistsCondition(false, sqlFileTrace);
  2420.             }
  2421.         }
  2422.         
  2423.     }
  2424.     public static void addFiltroConfigurazioneDump(String tipoDB,
  2425.             String aliasCONFIGPORTA,
  2426.             String filtroConfigurazioneDumpTipo, boolean erogazioni,
  2427.             ISQLQueryObject sqlQueryQuery) throws SQLQueryObjectException {

  2429.         String aliasDUMPCONFIG = "dump_c";
  2430.         
  2431.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2432.         sql.addFromTable(CostantiDB.DUMP_CONFIGURAZIONE, aliasDUMPCONFIG);
  2433.         sql.addSelectField(aliasDUMPCONFIG, CostantiDB.COLUMN_ID_PROPRIETARIO);
  2434.         sql.setANDLogicOperator(true);
  2435.         if(erogazioni) {
  2436.             sql.addWhereCondition(aliasCONFIGPORTA+".id="+aliasDUMPCONFIG+"."+CostantiDB.COLUMN_ID_PROPRIETARIO);
  2437.             sql.addWhereLikeCondition(aliasDUMPCONFIG+".proprietario", "pa", false, false, false);
  2438.         }
  2439.         else {
  2440.             sql.addWhereCondition(aliasCONFIGPORTA+".id="+aliasDUMPCONFIG+"."+CostantiDB.COLUMN_ID_PROPRIETARIO);
  2441.             sql.addWhereLikeCondition(aliasDUMPCONFIG+".proprietario", "pd", false, false, false);
  2442.         }   
  2443.         
  2444.         //Prepariamo anzi una utility per ogni singola voce e poi ad ogni if la si chiama!
  2445.         
  2446.         boolean and = true;
  2447.         boolean or = false;
  2448.         boolean notExists = true;
  2449.         boolean exists = false;
  2450.         
  2451.         if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_DEFAULT.equals(filtroConfigurazioneDumpTipo)) {
  2452.             sqlQueryQuery.addWhereExistsCondition(notExists, sql);  
  2453.         }
  2454.         else if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2455.                 ||
  2456.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2457.                 ||
  2458.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2459.                 ||
  2460.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2461.                 ||
  2462.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2463.                 ||
  2464.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2465.                 ||
  2466.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2467.                 ||
  2468.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2469.                 ||
  2470.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2471.                 ||
  2472.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2473.                 ||
  2474.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2475.                 ||
  2476.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2477.                 ||
  2478.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2479.                 ||
  2480.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2481.                 ){
  2482.             
  2483.             boolean soloHeader = (
  2484.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2485.                     ||
  2486.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2487.                     ||
  2488.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2489.                     ||
  2490.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2491.                     ||
  2492.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2493.                     ||
  2494.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2495.                     ||
  2496.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2497.                     );
  2498.             BooleanNullable payload = soloHeader ? BooleanNullable.FALSE() : BooleanNullable.TRUE();
  2499.             BooleanNullable headers = BooleanNullable.TRUE();
  2500.             
  2501.             boolean condizionePayloadHeaders = soloHeader ? and : or;
  2502.             
  2503.             List<ISQLQueryObject> sqlMessages = new ArrayList<>();
  2504.             
  2505.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2506.                     ||
  2507.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2508.                     ||
  2509.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2510.                     ||
  2511.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2512.                     ||
  2513.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2514.                     ||
  2515.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2516.                     ) {
  2517.                 ISQLQueryObject sqlRichiestaIngresso = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2518.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2519.                         aliasDUMPCONFIG, 
  2520.                         "id_richiesta_ingresso", payload, headers, condizionePayloadHeaders,
  2521.                         sqlRichiestaIngresso, exists);
  2522.                 sqlMessages.add(sqlRichiestaIngresso);
  2523.             }
  2524.             
  2525.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2526.                     ||
  2527.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2528.                     ||
  2529.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2530.                     ||
  2531.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2532.                     ||
  2533.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2534.                     ||
  2535.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RICHIESTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2536.                     ) {
  2537.                 ISQLQueryObject sqlRichiestaUscita = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2538.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2539.                         aliasDUMPCONFIG, 
  2540.                         "id_richiesta_uscita", payload, headers, condizionePayloadHeaders,
  2541.                         sqlRichiestaUscita, exists);
  2542.                 sqlMessages.add(sqlRichiestaUscita);
  2543.             }
  2544.             
  2545.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2546.                     ||
  2547.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2548.                     ||
  2549.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2550.                     ||
  2551.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2552.                     ||
  2553.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2554.                     ||
  2555.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_INGRESSO.equals(filtroConfigurazioneDumpTipo)
  2556.                     ) {
  2557.                 ISQLQueryObject sqlRispostaIngresso = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2558.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2559.                         aliasDUMPCONFIG, 
  2560.                         "id_risposta_ingresso", payload, headers, condizionePayloadHeaders,
  2561.                         sqlRispostaIngresso, exists);
  2562.                 sqlMessages.add(sqlRispostaIngresso);
  2563.             }
  2564.             
  2565.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO.equals(filtroConfigurazioneDumpTipo)
  2566.                     ||
  2567.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER.equals(filtroConfigurazioneDumpTipo)
  2568.                     ||
  2569.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2570.                     ||
  2571.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2572.                     ||
  2573.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2574.                     ||
  2575.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_ABILITATO_SOLO_HEADER_RISPOSTA_USCITA.equals(filtroConfigurazioneDumpTipo)
  2576.                     ) {
  2577.                 ISQLQueryObject sqlRispostaUscita = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2578.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2579.                         aliasDUMPCONFIG, 
  2580.                         "id_risposta_uscita", payload, headers, condizionePayloadHeaders,
  2581.                         sqlRispostaUscita, exists);
  2582.                 sqlMessages.add(sqlRispostaUscita);
  2583.             }
  2584.             
  2585.             setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2586.                     sql, or,
  2587.                     sqlMessages.toArray(new ISQLQueryObject[1]));
  2588.             sqlQueryQuery.addWhereExistsCondition(exists, sql); 
  2589.         }
  2590.         else if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO.equals(filtroConfigurazioneDumpTipo)
  2591.                 ||
  2592.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2593.                 ||
  2594.                 Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2595.                 ){
  2596.             
  2597.             BooleanNullable payload = BooleanNullable.FALSE();
  2598.             BooleanNullable headers = BooleanNullable.FALSE();
  2599.             
  2600.             boolean condizionePayloadHeaders = and;
  2601.             
  2602.             List<ISQLQueryObject> sqlMessages = new ArrayList<>();
  2603.             
  2604.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO.equals(filtroConfigurazioneDumpTipo)
  2605.                     ||
  2606.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RICHIESTA.equals(filtroConfigurazioneDumpTipo)
  2607.                     ) {
  2608.                 ISQLQueryObject sqlRichiestaIngresso = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2609.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2610.                         aliasDUMPCONFIG, 
  2611.                         "id_richiesta_ingresso", payload, headers, condizionePayloadHeaders,
  2612.                         sqlRichiestaIngresso, exists);
  2613.                 sqlMessages.add(sqlRichiestaIngresso);
  2614.                 
  2615.                 ISQLQueryObject sqlRichiestaUscita = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2616.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2617.                         aliasDUMPCONFIG, 
  2618.                         "id_richiesta_uscita", payload, headers, condizionePayloadHeaders,
  2619.                         sqlRichiestaUscita, exists);
  2620.                 sqlMessages.add(sqlRichiestaUscita);
  2621.             }

  2623.             if(Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO.equals(filtroConfigurazioneDumpTipo)
  2624.                     ||
  2625.                     Filtri.FILTRO_CONFIGURAZIONE_DUMP_TIPO_VALORE_RIDEFINITO_DISABILITATO_RISPOSTA.equals(filtroConfigurazioneDumpTipo)
  2626.                     ) {
  2627.                 ISQLQueryObject sqlRispostaIngresso = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2628.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2629.                         aliasDUMPCONFIG, 
  2630.                         "id_risposta_ingresso", payload, headers, condizionePayloadHeaders,
  2631.                         sqlRispostaIngresso, exists);
  2632.                 sqlMessages.add(sqlRispostaIngresso);
  2633.             
  2634.                 ISQLQueryObject sqlRispostaUscita = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2635.                 setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2636.                         aliasDUMPCONFIG, 
  2637.                         "id_risposta_uscita", payload, headers, condizionePayloadHeaders,
  2638.                         sqlRispostaUscita, exists);
  2639.                 sqlMessages.add(sqlRispostaUscita);
  2640.             }
  2641.             
  2642.             setFiltriDumpRegolaConfigurazioneDumpEngine(tipoDB,
  2643.                     sql, and,
  2644.                     sqlMessages.toArray(new ISQLQueryObject[1]));
  2645.             sqlQueryQuery.addWhereExistsCondition(exists, sql); 
  2646.         }
  2647.         
  2648.     }
  2649.     private static void setFiltriDumpRegolaConfigurazioneDumpEngine(String tipoDB,
  2650.             ISQLQueryObject sqlQueryObjectConditions, boolean and,
  2651.             ISQLQueryObject ... sqlQueryObjectMessage) throws SQLQueryObjectException {     
  2652.         List<String> conditions = new ArrayList<>();
  2653.         
  2654.         if(tipoDB!=null) {
  2655.             // ignore
  2656.         }
  2657.         
  2658.         if(sqlQueryObjectMessage!=null && sqlQueryObjectMessage.length>0) {
  2659.             for (ISQLQueryObject sql : sqlQueryObjectMessage) {
  2660.                 conditions.add(sql.createSQLConditions());  
  2661.             }
  2662.         }
  2663.         
  2664.         if(conditions.isEmpty()) {
  2665.             throw new SQLQueryObjectException("Usage error");
  2666.         }
  2667.         sqlQueryObjectConditions.addWhereCondition(and, conditions.toArray(new String[1]));
  2668.     }
  2669.     private static void setFiltriDumpRegolaConfigurazioneDumpEngine(String tipoDB,
  2670.             String aliasDUMPCONFIG, 
  2671.             String colonna, BooleanNullable payload, BooleanNullable headers, boolean and,
  2672.             ISQLQueryObject sqlQueryObjectConditions, boolean notExists) throws SQLQueryObjectException {
  2673.         
  2674.         if(tipoDB!=null) {
  2675.             // ignore
  2676.         }
  2677.         
  2678.         String aliasDUMPCONFIGREGOLE = "dump_cr";
  2679.         
  2680.         ISQLQueryObject sql = SQLObjectFactory.createSQLQueryObject(tipoDB);
  2681.         sql.addSelectField("id");
  2682.         sql.addFromTable(CostantiDB.DUMP_CONFIGURAZIONE_REGOLA, aliasDUMPCONFIGREGOLE);
  2683.         sql.setANDLogicOperator(true);
  2684.         sql.addWhereCondition(aliasDUMPCONFIG+"."+colonna+"="+aliasDUMPCONFIGREGOLE+".id");
  2685.         if(payload!=null && payload.getValue()!=null &&
  2686.                 headers!=null && headers.getValue()!=null) {
  2687.             sql.addWhereCondition(and, 
  2688.                     sql.getWhereLikeCondition("payload", payload.getValue()!=null && payload.getValue().booleanValue() ? "abilitato" : "disabilitato", false, false, false),
  2689.                     sql.getWhereLikeCondition("headers", headers.getValue()!=null && headers.getValue().booleanValue() ? "abilitato" : "disabilitato", false, false, false));
  2690.         }
  2691.         else if(payload!=null && payload.getValue()!=null) {
  2692.             sql.addWhereLikeCondition("payload", payload.getValue()!=null && payload.getValue().booleanValue() ? "abilitato" : "disabilitato", false, false, false);
  2693.         }
  2694.         else if(headers!=null && headers.getValue()!=null) {
  2695.             sql.addWhereLikeCondition("headers", headers.getValue()!=null && headers.getValue().booleanValue() ? "abilitato" : "disabilitato", false, false, false);
  2696.         }
  2697.         else {
  2698.             throw new SQLQueryObjectException("Usage error");
  2699.         }
  2700.         sqlQueryObjectConditions.addWhereExistsCondition(notExists, sql);
  2701.     }
  2702.     
  2703.     

  2705.     /**
  2706.      * Utility per formattare la string sql con i parametri passati, e stamparla per debug
  2707.      * @param sql la string sql utilizzata nel prepared statement
  2708.      * @param params i parametri da inserire nella stringa che sostituiranno i '?'
  2709.      * @return La stringa sql con al posto dei '?' ha i parametri passati
  2710.      */
  2711.     public static String formatSQLString(String sql,Object ... params)
  2712.     {
  2713.         String res = sql;

  2715.         for (int i = 0; i < params.length; i++)
  2716.         {
  2717.             res=res.replaceFirst("\\?", "{"+i+"}");
  2718.         }

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

  2722.     }


  2725.     
  2726.     
  2727.     
  2728.     public static List<String> convertToList(String v){
  2729.         List<String> l = new ArrayList<>();
  2730.         if(v!=null && !"".equals(v)) {
  2731.             if(v.contains(",")) {
  2732.                 String [] tmp = v.split(",");
  2733.                 for (int i = 0; i < tmp.length; i++) {
  2734.                     l.add(tmp[i].trim());
  2735.                 }
  2736.             }else {
  2737.                 l.add(v.trim());
  2738.             }
  2739.         }
  2740.         return l;
  2741.     }
  2742. }

Created with JaCoCo 0.8.8.202204050719