DriverConfigurazioneDB_allarmiDriver.java

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

  22. import java.sql.Connection;
  23. import java.sql.PreparedStatement;
  24. import java.sql.ResultSet;
  25. import java.util.ArrayList;
  26. import java.util.List;

  28. import org.openspcoop2.core.allarmi.Allarme;
  29. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  30. import org.openspcoop2.core.allarmi.constants.StatoAllarme;
  31. import org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils;
  32. import org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils;
  33. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  34. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  35. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  36. import org.openspcoop2.core.constants.CostantiDB;
  37. import org.openspcoop2.core.id.IDServizio;
  38. import org.openspcoop2.core.id.IDSoggetto;
  39. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  40. import org.openspcoop2.utils.sql.ISQLQueryObject;
  41. import org.openspcoop2.utils.sql.SQLObjectFactory;

  43. /**
  44.  * DriverConfigurazioneDB_allarmiDriver
  45.  * 
  46.  * 
  47.  * @author Sandra Giangrandi (sandra@link.it)
  48.  * @author Stefano Corallo (corallo@link.it)
  49.  * @author $Author$
  50.  * @version $Rev$, $Date$
  51.  */
  52. public class DriverConfigurazioneDB_allarmiDriver {

  54.     private DriverConfigurazioneDB driver = null;
  55.     
  56.     protected DriverConfigurazioneDB_allarmiDriver(DriverConfigurazioneDB driver) {
  57.         this.driver = driver;
  58.     }
  59.     
  60.     protected long countAllarmi(String tipologiaRicerca, Boolean enabled, StatoAllarme stato, Boolean acknowledged, String nomeAllarme,
  61.             List<IDSoggetto> listSoggettiProprietariAbilitati, List<IDServizio> listIDServizioAbilitati,
  62.             List<String> tipoSoggettiByProtocollo, List<String> tipoServiziByProtocollo, 
  63.             IDSoggetto idSoggettoProprietario, List<IDServizio> listIDServizio) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  64.         
  65.         Connection con = null;
  66.         ResultSet rs = null;
  67.         PreparedStatement stm = null;
  68.         
  69.         if (this.driver.atomica) {
  70.             try {
  71.                 con = this.driver.getConnectionFromDatasource("countAllarmi");

  73.             } catch (Exception e) {
  74.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::countAllarmi] Exception accedendo al datasource :" + e.getMessage(),e);

  76.             }

  78.         } else
  79.             con = this.driver.globalConnection;

  81.         try {
  82.             
  83.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  84.             sqlQueryObject.addFromTable(CostantiDB.ALLARMI);
  85.             sqlQueryObject.addSelectCountField(CostantiDB.ALLARMI + ".id", "numeroAllarmi");
  86.             sqlQueryObject.setANDLogicOperator(true);
  87.             
  88.             _setExpressionAllarmi(sqlQueryObject, tipologiaRicerca, enabled, stato, acknowledged, nomeAllarme,
  89.                     listSoggettiProprietariAbilitati, listIDServizioAbilitati,
  90.                     tipoSoggettiByProtocollo, tipoServiziByProtocollo, 
  91.                     idSoggettoProprietario, listIDServizio);
  92.             
  93.             String sqlQuery = sqlQueryObject.createSQLQuery();

  95.             stm = con.prepareStatement(sqlQuery);
  96.             
  97.             sqlQuery = _setExpressionAllarmiValues(stm, sqlQuery,
  98.                     tipologiaRicerca, enabled, stato, acknowledged, nomeAllarme,
  99.                     listSoggettiProprietariAbilitati, listIDServizioAbilitati,
  100.                     tipoSoggettiByProtocollo, tipoServiziByProtocollo, 
  101.                     idSoggettoProprietario, listIDServizio);
  102.             this.driver.logDebug("eseguo query: " + sqlQuery);
  103.             
  104.             rs = stm.executeQuery();
  105.             long numeroAllarmi = 0;
  106.             if(rs.next()) {
  107.                 
  108.                  numeroAllarmi = rs.getLong("numeroAllarmi");
  109.             }
  110.             rs.close(); rs=null;
  111.             stm.close(); stm = null;

  113.             return numeroAllarmi;
  114.             
  115.         } catch (Exception se) {
  116.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::countAllarmi] Exception: " + se.getMessage(),se);
  117.         } finally {
  118.             //Chiudo statement and resultset
  119.             JDBCUtilities.closeResources(rs, stm);
  120.             this.driver.closeConnection(con);
  121.         }
  122.         
  123.     }
  124.     
  125.     protected List<Allarme> findAllAllarmi(String tipologiaRicerca, Boolean enabled, StatoAllarme stato, Boolean acknowledged, String nomeAllarme,
  126.             List<IDSoggetto> listSoggettiProprietariAbilitati, List<IDServizio> listIDServizioAbilitati,
  127.             List<String> tipoSoggettiByProtocollo, List<String> tipoServiziByProtocollo, 
  128.             IDSoggetto idSoggettoProprietario, List<IDServizio> listIDServizio,
  129.             Integer offset, Integer limit) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  130.         
  131.         Connection con = null;
  132.         ResultSet rs = null;
  133.         PreparedStatement stm = null;
  134.         
  135.         if (this.driver.atomica) {
  136.             try {
  137.                 con = this.driver.getConnectionFromDatasource("findAllAllarmi");

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

  142.             }

  144.         } else
  145.             con = this.driver.globalConnection;

  147.         try {
  148.             
  149.             List<Allarme> list = new ArrayList<Allarme>();
  150.             
  151.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  152.             sqlQueryObject.addFromTable(CostantiDB.ALLARMI);
  153.             sqlQueryObject.addSelectField(CostantiDB.ALLARMI + ".id");
  154.             sqlQueryObject.addSelectField(CostantiDB.ALLARMI + ".alias");
  155.             sqlQueryObject.setANDLogicOperator(true);
  156.             
  157.             _setExpressionAllarmi(sqlQueryObject, tipologiaRicerca, enabled, stato, acknowledged, nomeAllarme,
  158.                     listSoggettiProprietariAbilitati, listIDServizioAbilitati,
  159.                     tipoSoggettiByProtocollo, tipoServiziByProtocollo, 
  160.                     idSoggettoProprietario, listIDServizio);
  161.             
  162.             sqlQueryObject.addOrderBy("alias");
  163.             
  164.             if(offset!=null) {
  165.                 sqlQueryObject.setOffset(offset);
  166.             }
  167.             if(limit!=null) {
  168.                 sqlQueryObject.setLimit(limit);
  169.             }
  170.             
  171.             String sqlQuery = sqlQueryObject.createSQLQuery();

  173.             stm = con.prepareStatement(sqlQuery);

  175.             sqlQuery = _setExpressionAllarmiValues(stm, sqlQuery,
  176.                     tipologiaRicerca, enabled, stato, acknowledged, nomeAllarme,
  177.                     listSoggettiProprietariAbilitati, listIDServizioAbilitati,
  178.                     tipoSoggettiByProtocollo, tipoServiziByProtocollo, 
  179.                     idSoggettoProprietario, listIDServizio);
  180.             this.driver.logDebug("eseguo query: " + sqlQuery);
  181.             
  182.             rs = stm.executeQuery();
  183.             while(rs.next()) {
  184.                 
  185.                 long idAllarme = rs.getLong("id");
  186.                 list.add(AllarmiDriverUtils.getAllarme(idAllarme, con, this.driver.log, this.driver.tipoDB));
  187.                 
  188.             }
  189.             rs.close(); rs=null;
  190.             stm.close(); stm = null;

  192.             return list;
  193.             
  194.         } catch (Exception se) {
  195.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::findAllAllarmi] Exception: " + se.getMessage(),se);
  196.         } finally {
  197.             //Chiudo statement and resultset
  198.             JDBCUtilities.closeResources(rs, stm);
  199.             this.driver.closeConnection(con);
  200.         }
  201.         
  202.     }
  203.     
  204.     private void _setExpressionAllarmi(ISQLQueryObject sqlQueryObject, String tipologiaRicerca, Boolean enabled, StatoAllarme stato, Boolean acknowledged, String nomeAllarme,
  205.             List<IDSoggetto> listSoggettiProprietariAbilitati, List<IDServizio> listIDServizioAbilitati,
  206.             List<String> tipoSoggettiByProtocollo, List<String> tipoServiziByProtocollo, 
  207.             IDSoggetto idSoggettoProprietario, List<IDServizio> listIDServizio) throws Exception {
  208.         if(enabled!=null){
  209.             sqlQueryObject.addWhereCondition("enabled=?");
  210.         }
  211.         if(stato!=null){
  212.             sqlQueryObject.addWhereCondition("stato=?");
  213.         }
  214.         if(acknowledged!=null){
  215.             sqlQueryObject.addWhereCondition("acknowledged=?");
  216.         }
  217.         
  218.         if(nomeAllarme!=null) {
  219.             sqlQueryObject.addWhereLikeCondition("alias", nomeAllarme, true, true);
  220.         }
  221.         
  222.         ISQLQueryObject sqlQueryObjectPorteApplicative = null;
  223.         ISQLQueryObject sqlQueryObjectPorteDelegate = null;
  224.         
  225.         if(CostantiConfigurazione.ALLARMI_TIPOLOGIA_CONFIGURAZIONE.equals(tipologiaRicerca)) {
  226.             sqlQueryObject.addWhereIsNullCondition("filtro_porta");
  227.         }
  228.         
  229.         if(CostantiConfigurazione.ALLARMI_TIPOLOGIA_APPLICATIVA.equals(tipologiaRicerca) || CostantiConfigurazione.ALLARMI_TIPOLOGIA_SOLO_ASSOCIATE.equals(tipologiaRicerca)) {
  230.         
  231.             String alias_PA = "pa";
  232.             String alias_SOGGETTI = "sog";
  233.             
  234.             sqlQueryObjectPorteApplicative = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  235.             sqlQueryObjectPorteApplicative.addFromTable(CostantiDB.PORTE_APPLICATIVE,alias_PA);
  236.             sqlQueryObjectPorteApplicative.setANDLogicOperator(true);
  237.             sqlQueryObjectPorteApplicative.addWhereCondition(CostantiDB.ALLARMI+".filtro_ruolo=?");
  238.             sqlQueryObjectPorteApplicative.addWhereCondition(CostantiDB.ALLARMI+".filtro_porta="+alias_PA+".nome_porta");
  239.             sqlQueryObjectPorteApplicative.addWhereIsNotNullCondition(alias_PA+".tipo_servizio");
  240.             sqlQueryObjectPorteApplicative.addWhereIsNotNullCondition(alias_PA+".servizio");
  241.             sqlQueryObjectPorteApplicative.addWhereIsNotNullCondition(alias_PA+".versione_servizio");
  242.             
  243.             if( (listSoggettiProprietariAbilitati!=null && !listSoggettiProprietariAbilitati.isEmpty())
  244.                     ||
  245.                 (listIDServizioAbilitati!=null && !listIDServizioAbilitati.isEmpty()) 
  246.                     ||
  247.                 (tipoSoggettiByProtocollo!=null && !tipoSoggettiByProtocollo.isEmpty())
  248.                     ||
  249.                 idSoggettoProprietario!=null
  250.                     ||
  251.                 listIDServizio!=null && !listIDServizio.isEmpty()
  252.                     ) {
  253.                 sqlQueryObjectPorteApplicative.addFromTable(CostantiDB.SOGGETTI,alias_SOGGETTI);
  254.                 sqlQueryObjectPorteApplicative.addWhereCondition(alias_PA+".id_soggetto = "+alias_SOGGETTI+".id");
  255.             }
  256.             
  257.             
  258.             
  259.             // Utenza permessi
  260.             
  261.             List<String> condizioniUtenza = new ArrayList<>();
  262.             
  263.             if(listSoggettiProprietariAbilitati!=null && !listSoggettiProprietariAbilitati.isEmpty()) {
  264.                 ISQLQueryObject sqlQueryObjectUtenzaSoggetto = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  265.                 sqlQueryObjectUtenzaSoggetto.setANDLogicOperator(true);
  266.                 List<String> condizioni = new ArrayList<>();
  267.                 for (@SuppressWarnings("unused") IDSoggetto idSoggetto : listSoggettiProprietariAbilitati) {
  268.                     ISQLQueryObject sqlQueryObjectSoggetto = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  269.                     sqlQueryObjectSoggetto.setANDLogicOperator(true);
  270.                     sqlQueryObjectSoggetto.addWhereCondition(alias_SOGGETTI+".tipo_soggetto = ?");
  271.                     sqlQueryObjectSoggetto.addWhereCondition(alias_SOGGETTI+".nome_soggetto = ?");
  272.                     condizioni.add(sqlQueryObjectSoggetto.createSQLConditions());
  273.                 }
  274.                 sqlQueryObjectUtenzaSoggetto.addWhereCondition(false, condizioni.toArray(new String[condizioni.size()]));
  275.                 
  276.                 condizioniUtenza.add(sqlQueryObjectUtenzaSoggetto.createSQLConditions());
  277.             }
  278.             if(listIDServizioAbilitati!=null && !listIDServizioAbilitati.isEmpty()) {
  279.                 ISQLQueryObject sqlQueryObjectUtenzaServizio = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  280.                 sqlQueryObjectUtenzaServizio.setANDLogicOperator(true);
  281.                 List<String> condizioni = new ArrayList<>();
  282.                 for (@SuppressWarnings("unused") IDServizio idServizio : listIDServizioAbilitati) {
  283.                     ISQLQueryObject sqlQueryObjectServizio = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  284.                     sqlQueryObjectServizio.setANDLogicOperator(true);
  285.                     sqlQueryObjectServizio.addWhereCondition(alias_SOGGETTI+".tipo_soggetto = ?");
  286.                     sqlQueryObjectServizio.addWhereCondition(alias_SOGGETTI+".nome_soggetto = ?");
  287.                     sqlQueryObjectServizio.addWhereCondition(alias_PA+".tipo_servizio = ?");
  288.                     sqlQueryObjectServizio.addWhereCondition(alias_PA+".servizio = ?");
  289.                     sqlQueryObjectServizio.addWhereCondition(alias_PA+".versione_servizio = ?");
  290.                     condizioni.add(sqlQueryObjectServizio.createSQLConditions());
  291.                 }
  292.                 sqlQueryObjectUtenzaServizio.addWhereCondition(false, condizioni.toArray(new String[condizioni.size()]));
  293.                 
  294.                 condizioniUtenza.add(sqlQueryObjectUtenzaServizio.createSQLConditions());
  295.             }
  296.             
  297.             if(!condizioniUtenza.isEmpty()) {
  298.                 sqlQueryObjectPorteApplicative.addWhereCondition(false, condizioniUtenza.toArray(new String[condizioniUtenza.size()]));
  299.             }
  300.         
  301.             // protocollo
  302.             if(tipoSoggettiByProtocollo!=null && !tipoSoggettiByProtocollo.isEmpty()) {
  303.                 sqlQueryObjectPorteApplicative.addWhereINCondition(alias_SOGGETTI+".tipo_soggetto", true, tipoSoggettiByProtocollo.toArray(new String[tipoSoggettiByProtocollo.size()]));
  304.             }
  305.             if(tipoServiziByProtocollo!=null && !tipoServiziByProtocollo.isEmpty()) {
  306.                 sqlQueryObjectPorteApplicative.addWhereINCondition(alias_PA+".tipo_servizio", true, tipoServiziByProtocollo.toArray(new String[tipoServiziByProtocollo.size()]));
  307.             }
  308.             
  309.             // soggetto proprietario
  310.             if(idSoggettoProprietario!=null) {
  311.                 sqlQueryObjectPorteApplicative.addWhereCondition(alias_SOGGETTI+".tipo_soggetto = ?");
  312.                 sqlQueryObjectPorteApplicative.addWhereCondition(alias_SOGGETTI+".nome_soggetto = ?");
  313.             }
  314.             
  315.             // servizi
  316.             if(listIDServizio!=null && !listIDServizio.isEmpty()) {
  317.                 
  318.                 if(listIDServizio.size()==1) {
  319.                     sqlQueryObjectPorteApplicative.addWhereCondition(alias_SOGGETTI+".tipo_soggetto = ?");
  320.                     sqlQueryObjectPorteApplicative.addWhereCondition(alias_SOGGETTI+".nome_soggetto = ?");
  321.                     sqlQueryObjectPorteApplicative.addWhereCondition(alias_PA+".tipo_servizio = ?");
  322.                     sqlQueryObjectPorteApplicative.addWhereCondition(alias_PA+".servizio = ?");
  323.                     sqlQueryObjectPorteApplicative.addWhereCondition(alias_PA+".versione_servizio = ?");
  324.                 }
  325.                 else {
  326.                     List<String> condizioni = new ArrayList<>();
  327.                     for (@SuppressWarnings("unused") IDServizio idServizio : listIDServizio) {
  328.                         ISQLQueryObject sqlQueryObjectServizio = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  329.                         sqlQueryObjectServizio.setANDLogicOperator(true);
  330.                         sqlQueryObjectServizio.addWhereCondition(alias_SOGGETTI+".tipo_soggetto = ?");
  331.                         sqlQueryObjectServizio.addWhereCondition(alias_SOGGETTI+".nome_soggetto = ?");
  332.                         sqlQueryObjectServizio.addWhereCondition(alias_PA+".tipo_servizio = ?");
  333.                         sqlQueryObjectServizio.addWhereCondition(alias_PA+".servizio = ?");
  334.                         sqlQueryObjectServizio.addWhereCondition(alias_PA+".versione_servizio = ?");
  335.                         condizioni.add(sqlQueryObjectServizio.createSQLConditions());
  336.                     }
  337.                     sqlQueryObjectPorteApplicative.addWhereCondition(false, condizioni.toArray(new String[condizioni.size()]));
  338.                 }
  339.                 
  340.             }
  341.             
  342.         }
  343.         
  344.         if(CostantiConfigurazione.ALLARMI_TIPOLOGIA_DELEGATA.equals(tipologiaRicerca) || CostantiConfigurazione.ALLARMI_TIPOLOGIA_SOLO_ASSOCIATE.equals(tipologiaRicerca)) {
  345.             
  346.             String alias_PD = "pd";
  347.             String alias_SOGGETTI = "sog";
  348.             
  349.             sqlQueryObjectPorteDelegate = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  350.             sqlQueryObjectPorteDelegate.addFromTable(CostantiDB.PORTE_DELEGATE,alias_PD);
  351.             sqlQueryObjectPorteDelegate.setANDLogicOperator(true);
  352.             sqlQueryObjectPorteDelegate.addWhereCondition(CostantiDB.ALLARMI+".filtro_ruolo=?");
  353.             sqlQueryObjectPorteDelegate.addWhereCondition(CostantiDB.ALLARMI+".filtro_porta="+alias_PD+".nome_porta");
  354.             sqlQueryObjectPorteDelegate.addWhereIsNotNullCondition(alias_PD+".tipo_soggetto_erogatore");
  355.             sqlQueryObjectPorteDelegate.addWhereIsNotNullCondition(alias_PD+".nome_soggetto_erogatore");
  356.             sqlQueryObjectPorteDelegate.addWhereIsNotNullCondition(alias_PD+".tipo_servizio");
  357.             sqlQueryObjectPorteDelegate.addWhereIsNotNullCondition(alias_PD+".nome_servizio");
  358.             sqlQueryObjectPorteDelegate.addWhereIsNotNullCondition(alias_PD+".versione_servizio");
  359.             
  360.             if( (listSoggettiProprietariAbilitati!=null && !listSoggettiProprietariAbilitati.isEmpty())
  361.                     ||
  362.                 (tipoSoggettiByProtocollo!=null && !tipoSoggettiByProtocollo.isEmpty())
  363.                     ||
  364.                 (tipoServiziByProtocollo!=null && !tipoServiziByProtocollo.isEmpty())
  365.                     ||
  366.                 idSoggettoProprietario!=null
  367.                     ) {
  368.                 sqlQueryObjectPorteDelegate.addFromTable(CostantiDB.SOGGETTI,alias_SOGGETTI);
  369.                 sqlQueryObjectPorteDelegate.addWhereCondition(alias_PD+".id_soggetto = "+alias_SOGGETTI+".id");
  370.             }
  371.             
  372.             
  373.             
  374.             // Utenza permessi
  375.             
  376.             List<String> condizioniUtenza = new ArrayList<>();
  377.             
  378.             if(listSoggettiProprietariAbilitati!=null && !listSoggettiProprietariAbilitati.isEmpty()) {
  379.                 ISQLQueryObject sqlQueryObjectUtenzaSoggetto = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  380.                 sqlQueryObjectUtenzaSoggetto.setANDLogicOperator(true);
  381.                 List<String> condizioni = new ArrayList<>();
  382.                 for (@SuppressWarnings("unused") IDSoggetto idSoggetto : listSoggettiProprietariAbilitati) {
  383.                     ISQLQueryObject sqlQueryObjectSoggetto = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  384.                     sqlQueryObjectSoggetto.setANDLogicOperator(true);
  385.                     sqlQueryObjectSoggetto.addWhereCondition(alias_SOGGETTI+".tipo_soggetto = ?");
  386.                     sqlQueryObjectSoggetto.addWhereCondition(alias_SOGGETTI+".nome_soggetto = ?");
  387.                     condizioni.add(sqlQueryObjectSoggetto.createSQLConditions());
  388.                 }
  389.                 sqlQueryObjectUtenzaSoggetto.addWhereCondition(false, condizioni.toArray(new String[condizioni.size()]));
  390.                 
  391.                 condizioniUtenza.add(sqlQueryObjectUtenzaSoggetto.createSQLConditions());
  392.             }
  393.             if(listIDServizioAbilitati!=null && !listIDServizioAbilitati.isEmpty()) {
  394.                 ISQLQueryObject sqlQueryObjectUtenzaServizio = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  395.                 sqlQueryObjectUtenzaServizio.setANDLogicOperator(true);
  396.                 List<String> condizioni = new ArrayList<>();
  397.                 for (@SuppressWarnings("unused") IDServizio idServizio : listIDServizioAbilitati) {
  398.                     ISQLQueryObject sqlQueryObjectServizio = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  399.                     sqlQueryObjectServizio.setANDLogicOperator(true);
  400.                     sqlQueryObjectServizio.addWhereCondition(alias_PD+".tipo_soggetto_erogatore = ?");
  401.                     sqlQueryObjectServizio.addWhereCondition(alias_PD+".nome_soggetto_erogatore = ?");
  402.                     sqlQueryObjectServizio.addWhereCondition(alias_PD+".tipo_servizio = ?");
  403.                     sqlQueryObjectServizio.addWhereCondition(alias_PD+".nome_servizio = ?");
  404.                     sqlQueryObjectServizio.addWhereCondition(alias_PD+".versione_servizio = ?");
  405.                     condizioni.add(sqlQueryObjectServizio.createSQLConditions());
  406.                 }
  407.                 sqlQueryObjectUtenzaServizio.addWhereCondition(false, condizioni.toArray(new String[condizioni.size()]));
  408.                 
  409.                 condizioniUtenza.add(sqlQueryObjectUtenzaServizio.createSQLConditions());
  410.             }
  411.             
  412.             if(!condizioniUtenza.isEmpty()) {
  413.                 sqlQueryObjectPorteDelegate.addWhereCondition(false, condizioniUtenza.toArray(new String[condizioniUtenza.size()]));
  414.             }
  415.         
  416.             // protocollo
  417.             if(tipoSoggettiByProtocollo!=null && !tipoSoggettiByProtocollo.isEmpty()) {
  418.                 sqlQueryObjectPorteDelegate.addWhereINCondition(alias_SOGGETTI+".tipo_soggetto", true, tipoSoggettiByProtocollo.toArray(new String[tipoSoggettiByProtocollo.size()]));
  419.                 sqlQueryObjectPorteDelegate.addWhereINCondition(alias_PD+".tipo_soggetto_erogatore", true, tipoSoggettiByProtocollo.toArray(new String[tipoSoggettiByProtocollo.size()]));
  420.             }
  421.             if(tipoServiziByProtocollo!=null && !tipoServiziByProtocollo.isEmpty()) {
  422.                 sqlQueryObjectPorteDelegate.addWhereINCondition(alias_PD+".tipo_servizio", true, tipoServiziByProtocollo.toArray(new String[tipoServiziByProtocollo.size()]));
  423.             }
  424.             
  425.             // soggetto proprietario
  426.             if(idSoggettoProprietario!=null) {
  427.                 sqlQueryObjectPorteDelegate.addWhereCondition(alias_SOGGETTI+".tipo_soggetto = ?");
  428.                 sqlQueryObjectPorteDelegate.addWhereCondition(alias_SOGGETTI+".nome_soggetto = ?");
  429.             }
  430.             
  431.             // servizi
  432.             if(listIDServizio!=null && !listIDServizio.isEmpty()) {
  433.                 
  434.                 if(listIDServizio.size()==1) {
  435.                     sqlQueryObjectPorteDelegate.addWhereCondition(alias_PD+".tipo_soggetto_erogatore = ?");
  436.                     sqlQueryObjectPorteDelegate.addWhereCondition(alias_PD+".nome_soggetto_erogatore = ?");
  437.                     sqlQueryObjectPorteDelegate.addWhereCondition(alias_PD+".tipo_servizio = ?");
  438.                     sqlQueryObjectPorteDelegate.addWhereCondition(alias_PD+".nome_servizio = ?");
  439.                     sqlQueryObjectPorteDelegate.addWhereCondition(alias_PD+".versione_servizio = ?");
  440.                 }
  441.                 else {
  442.                     List<String> condizioni = new ArrayList<>();
  443.                     for (@SuppressWarnings("unused") IDServizio idServizio : listIDServizio) {
  444.                         ISQLQueryObject sqlQueryObjectServizio = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  445.                         sqlQueryObjectServizio.setANDLogicOperator(true);
  446.                         sqlQueryObjectServizio.addWhereCondition(alias_PD+".tipo_soggetto_erogatore = ?");
  447.                         sqlQueryObjectServizio.addWhereCondition(alias_PD+".nome_soggetto_erogatore = ?");
  448.                         sqlQueryObjectServizio.addWhereCondition(alias_PD+".tipo_servizio = ?");
  449.                         sqlQueryObjectServizio.addWhereCondition(alias_PD+".nome_servizio = ?");
  450.                         sqlQueryObjectServizio.addWhereCondition(alias_PD+".versione_servizio = ?");
  451.                         condizioni.add(sqlQueryObjectServizio.createSQLConditions());
  452.                     }
  453.                     sqlQueryObjectPorteDelegate.addWhereCondition(false, condizioni.toArray(new String[condizioni.size()]));
  454.                 }
  455.                 
  456.             }
  457.             
  458.         }
  459.         
  460.         if(sqlQueryObjectPorteApplicative!=null && sqlQueryObjectPorteDelegate!=null) {
  461.             ISQLQueryObject sqlQueryObjectOR = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  462.             sqlQueryObjectOR.setANDLogicOperator(false);
  463.             sqlQueryObjectOR.addWhereExistsCondition(false, sqlQueryObjectPorteApplicative);
  464.             sqlQueryObjectOR.addWhereExistsCondition(false, sqlQueryObjectPorteDelegate);
  465.             sqlQueryObject.addWhereCondition(sqlQueryObjectOR.createSQLConditions());
  466.         }
  467.         else if(sqlQueryObjectPorteApplicative!=null) {
  468.             sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectPorteApplicative);
  469.         }
  470.         else if(sqlQueryObjectPorteDelegate!=null) {
  471.             sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectPorteDelegate);
  472.         }
  473.         
  474.     }
  475.     private String _setExpressionAllarmiValues(PreparedStatement stm, String query, 
  476.             String tipologiaRicerca,Boolean enabled, StatoAllarme stato, Boolean acknowledged, String nomeAllarme,
  477.             List<IDSoggetto> listSoggettiProprietariAbilitati, List<IDServizio> listIDServizioAbilitati,
  478.             List<String> tipoSoggettiByProtocollo, List<String> tipoServiziByProtocollo, 
  479.             IDSoggetto idSoggettoProprietario, List<IDServizio> listIDServizio) throws Exception {
  480.         int index = 1;
  481.         if(enabled!=null){
  482.             int v = enabled? CostantiDB.TRUE : CostantiDB.FALSE;
  483.             stm.setInt(index++, v);
  484.             query = query.replaceFirst("\\?", v+"");
  485.         }
  486.         if(stato!=null){
  487.             int v = AllarmiConverterUtils.toIntegerValue(stato);
  488.             stm.setInt(index++,v);
  489.             query = query.replaceFirst("\\?", v+"");
  490.         }
  491.         if(acknowledged!=null){
  492.             int v = acknowledged? CostantiDB.TRUE : CostantiDB.FALSE;
  493.             stm.setInt(index++, v);
  494.             query = query.replaceFirst("\\?", v+"");
  495.         }
  496.                 
  497.         if(nomeAllarme!=null) {
  498.             // nop
  499.         }
  500.         
  501. //      if(CostantiConfigurazione.ALLARMI_TIPOLOGIA_CONFIGURAZIONE.equals(tipologiaRicerca)) {
  502. //          // nop
  503. //      }
  504.         
  505.         if(CostantiConfigurazione.ALLARMI_TIPOLOGIA_APPLICATIVA.equals(tipologiaRicerca) || CostantiConfigurazione.ALLARMI_TIPOLOGIA_SOLO_ASSOCIATE.equals(tipologiaRicerca)) {
  506.             
  507.             stm.setString(index++, RuoloPorta.APPLICATIVA.getValue()); query = query.replaceFirst("\\?", "'"+RuoloPorta.APPLICATIVA.getValue()+"'");
  508.                         
  509.             // Utenza permessi

  511.             if(listSoggettiProprietariAbilitati!=null && !listSoggettiProprietariAbilitati.isEmpty()) {
  512.                 for (IDSoggetto idSoggetto : listSoggettiProprietariAbilitati) {
  513.                     stm.setString(index++, idSoggetto.getTipo()); query = query.replaceFirst("\\?", "'"+idSoggetto.getTipo()+"'");
  514.                     stm.setString(index++, idSoggetto.getNome()); query = query.replaceFirst("\\?", "'"+idSoggetto.getNome()+"'");
  515.                 }
  516.             }
  517.             if(listIDServizioAbilitati!=null && !listIDServizioAbilitati.isEmpty()) {
  518.                 for (IDServizio idServizio : listIDServizioAbilitati) {
  519.                     stm.setString(index++, idServizio.getSoggettoErogatore().getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getTipo()+"'");
  520.                     stm.setString(index++, idServizio.getSoggettoErogatore().getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getNome()+"'");
  521.                     stm.setString(index++, idServizio.getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getTipo()+"'");
  522.                     stm.setString(index++, idServizio.getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getNome()+"'");
  523.                     stm.setInt(index++, idServizio.getVersione()); query = query.replaceFirst("\\?", idServizio.getVersione()+"");
  524.                 }
  525.             }

  527.             // protocollo
  528.             // nop
  529.             
  530.             // soggetto proprietario
  531.             if(idSoggettoProprietario!=null) {
  532.                 stm.setString(index++, idSoggettoProprietario.getTipo()); query = query.replaceFirst("\\?", "'"+idSoggettoProprietario.getTipo()+"'");
  533.                 stm.setString(index++, idSoggettoProprietario.getNome()); query = query.replaceFirst("\\?", "'"+idSoggettoProprietario.getNome()+"'");
  534.             }
  535.             
  536.             // servizi
  537.             if(listIDServizio!=null && !listIDServizio.isEmpty()) {
  538.                 
  539.                 if(listIDServizio.size()==1) {
  540.                     IDServizio idServizio = listIDServizio.get(0);
  541.                     stm.setString(index++, idServizio.getSoggettoErogatore().getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getTipo()+"'");
  542.                     stm.setString(index++, idServizio.getSoggettoErogatore().getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getNome()+"'");
  543.                     stm.setString(index++, idServizio.getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getTipo()+"'");
  544.                     stm.setString(index++, idServizio.getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getNome()+"'");
  545.                     stm.setInt(index++, idServizio.getVersione()); query = query.replaceFirst("\\?", idServizio.getVersione()+"");
  546.                 }
  547.                 else {
  548.                     for (IDServizio idServizio : listIDServizio) {
  549.                         stm.setString(index++, idServizio.getSoggettoErogatore().getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getTipo()+"'");
  550.                         stm.setString(index++, idServizio.getSoggettoErogatore().getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getNome()+"'");
  551.                         stm.setString(index++, idServizio.getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getTipo()+"'");
  552.                         stm.setString(index++, idServizio.getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getNome()+"'");
  553.                         stm.setInt(index++, idServizio.getVersione()); query = query.replaceFirst("\\?", idServizio.getVersione()+"");
  554.                     }
  555.                 }
  556.                 
  557.             }
  558.             
  559.         }
  560.         
  561.         if(CostantiConfigurazione.ALLARMI_TIPOLOGIA_DELEGATA.equals(tipologiaRicerca) || CostantiConfigurazione.ALLARMI_TIPOLOGIA_SOLO_ASSOCIATE.equals(tipologiaRicerca)) {
  562.             
  563.             stm.setString(index++, RuoloPorta.DELEGATA.getValue()); query = query.replaceFirst("\\?", "'"+RuoloPorta.DELEGATA.getValue()+"'");
  564.             
  565.             // Utenza permessi
  566.             
  567.             if(listSoggettiProprietariAbilitati!=null && !listSoggettiProprietariAbilitati.isEmpty()) {
  568.                 for (IDSoggetto idSoggetto : listSoggettiProprietariAbilitati) {
  569.                     stm.setString(index++, idSoggetto.getTipo()); query = query.replaceFirst("\\?", "'"+idSoggetto.getTipo()+"'");
  570.                     stm.setString(index++, idSoggetto.getNome()); query = query.replaceFirst("\\?", "'"+idSoggetto.getNome()+"'");
  571.                 }
  572.             }
  573.             if(listIDServizioAbilitati!=null && !listIDServizioAbilitati.isEmpty()) {
  574.                 for (IDServizio idServizio : listIDServizioAbilitati) {
  575.                     stm.setString(index++, idServizio.getSoggettoErogatore().getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getTipo()+"'");
  576.                     stm.setString(index++, idServizio.getSoggettoErogatore().getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getNome()+"'");
  577.                     stm.setString(index++, idServizio.getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getTipo()+"'");
  578.                     stm.setString(index++, idServizio.getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getNome()+"'");
  579.                     stm.setInt(index++, idServizio.getVersione()); query = query.replaceFirst("\\?", idServizio.getVersione()+"");
  580.                 }
  581.             }
  582.             
  583.             // protocollo
  584.             // nop
  585.             
  586.             // soggetto proprietario
  587.             if(idSoggettoProprietario!=null) {
  588.                 stm.setString(index++, idSoggettoProprietario.getTipo()); query = query.replaceFirst("\\?", "'"+idSoggettoProprietario.getTipo()+"'");
  589.                 stm.setString(index++, idSoggettoProprietario.getNome()); query = query.replaceFirst("\\?", "'"+idSoggettoProprietario.getNome()+"'");
  590.             }
  591.             
  592.             // servizi
  593.             if(listIDServizio!=null && !listIDServizio.isEmpty()) {
  594.                 
  595.                 if(listIDServizio.size()==1) {
  596.                     IDServizio idServizio = listIDServizio.get(0);
  597.                     stm.setString(index++, idServizio.getSoggettoErogatore().getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getTipo()+"'");
  598.                     stm.setString(index++, idServizio.getSoggettoErogatore().getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getNome()+"'");
  599.                     stm.setString(index++, idServizio.getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getTipo()+"'");
  600.                     stm.setString(index++, idServizio.getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getNome()+"'");
  601.                     stm.setInt(index++, idServizio.getVersione()); query = query.replaceFirst("\\?", idServizio.getVersione()+"");
  602.                 }
  603.                 else {
  604.                     for (IDServizio idServizio : listIDServizio) {
  605.                         stm.setString(index++, idServizio.getSoggettoErogatore().getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getTipo()+"'");
  606.                         stm.setString(index++, idServizio.getSoggettoErogatore().getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getSoggettoErogatore().getNome()+"'");
  607.                         stm.setString(index++, idServizio.getTipo()); query = query.replaceFirst("\\?", "'"+idServizio.getTipo()+"'");
  608.                         stm.setString(index++, idServizio.getNome()); query = query.replaceFirst("\\?", "'"+idServizio.getNome()+"'");
  609.                         stm.setInt(index++, idServizio.getVersione()); query = query.replaceFirst("\\?", idServizio.getVersione()+"");
  610.                     }
  611.                 }
  612.                 
  613.             }
  614.             
  615.         }
  616.         
  617.         return query;
  618.     }
  619. }
Created with JaCoCo 0.8.8.202204050719