DBOggettiInUsoUtils_serviziApplicativi.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.  */

  21. package org.openspcoop2.protocol.engine.utils;

  23. import java.sql.Connection;
  24. import java.sql.PreparedStatement;
  25. import java.sql.ResultSet;
  26. import java.util.ArrayList;
  27. import java.util.List;
  28. import java.util.Map;
  29. import java.util.Set;

  31. import org.openspcoop2.core.commons.DBUtils;
  32. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  33. import org.openspcoop2.core.config.constants.RuoloTipoMatch;
  34. import org.openspcoop2.core.constants.CostantiDB;
  35. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  36. import org.openspcoop2.core.id.IDPortaApplicativa;
  37. import org.openspcoop2.core.id.IDServizio;
  38. import org.openspcoop2.core.id.IDServizioApplicativo;
  39. import org.openspcoop2.core.mapping.DBMappingUtils;
  40. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  41. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  42. import org.openspcoop2.protocol.engine.constants.Costanti;
  43. import org.openspcoop2.utils.UtilsException;
  44. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  45. import org.openspcoop2.utils.sql.ISQLQueryObject;
  46. import org.openspcoop2.utils.sql.SQLObjectFactory;

  48. /**
  49.  * DBOggettiInUsoUtils_serviziApplicativi
  50.  * 
  51.  * @author Andrea Poli (apoli@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  * 
  55.  */
  56. public class DBOggettiInUsoUtils_serviziApplicativi {


  59.     protected static boolean isServizioApplicativoInUso(Connection con, String tipoDB, IDServizioApplicativo idServizioApplicativo, 
  60.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean isRegistroServiziLocale, boolean normalizeObjectIds,
  61.             boolean verificaRuoli) throws UtilsException {

  63.         if(isRegistroServiziLocale) {
  64.             // nop
  65.         }
  66.         
  67.         String nomeMetodo = "isServizioApplicativoInUso";

  69.         PreparedStatement stmt = null;
  70.         ResultSet risultato = null;
  71.         PreparedStatement stmt2 = null;
  72.         ResultSet risultato2 = null;
  73.         String queryString;
  74.         try {
  75.             boolean isInUso = false;

  77.             long idServizioApplicativoLong = DBUtils.getIdServizioApplicativo(idServizioApplicativo.getNome(), 
  78.                     idServizioApplicativo.getIdSoggettoProprietario().getTipo(), 
  79.                     idServizioApplicativo.getIdSoggettoProprietario().getNome(), 
  80.                     con, tipoDB);
  81.             if(idServizioApplicativoLong<=0){
  82.                 throw new UtilsException("Servizio Applicativo con id ["+idServizioApplicativo+"] non trovato");
  83.             }


  86.             List<String> autorizzazionePDMappingList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING);
  87.             List<String> autorizzazionePDList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE);
  88.             List<String> autorizzazionePAMappingList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA);
  89.             List<String> autorizzazionePAList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_PA);
  90.             List<String> autorizzazionePAMappingModiList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA_MODI);
  91.             List<String> autorizzazionePAModiList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_PA_MODI);
  92.             List<String> autorizzazioneTokenPDMappingList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_MAPPING_PD);
  93.             List<String> autorizzazioneTokenPDList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_PD);
  94.             List<String> autorizzazioneTokenPAMappingList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_MAPPING_PA);
  95.             List<String> autorizzazioneTokenPAList = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_PA);
  96.             List<String> ruoliPDMappingList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_MAPPING);
  97.             List<String> ruoliPDList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI);
  98.             List<String> ruoliPAMappingList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_MAPPING_PA);
  99.             List<String> ruoliPAList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_PA);
  100.             List<String> ruoliTokenPDMappingList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PD);
  101.             List<String> ruoliTokenPDList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PD);
  102.             List<String> ruoliTokenPAMappingList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA);
  103.             List<String> ruoliTokenPAList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PA);
  104.             List<String> ruoliTokenPAMappingModiList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA_MODI);
  105.             List<String> ruoliTokenPAModiList = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PA_MODI);
  106.             List<String> porteApplicativeList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  107.             List<String> porteApplicativeMappingList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  108.             List<String> ctList = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  109.             List<String> allarmeList = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI);
  110.             List<String> trasformazionePDMappingList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PD);
  111.             List<String> trasformazionePDList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PD);
  112.             List<String> trasformazionePAMappingList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA);
  113.             List<String> trasformazionePAList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PA);
  114.             List<String> modiSignalHubList = whereIsInUso.get(ErrorsHandlerCostant.IS_RIFERITA_MODI_SIGNAL_HUB);
  115.             
  116.             if (autorizzazionePDMappingList == null) {
  117.                 autorizzazionePDMappingList = new ArrayList<>();
  118.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING, autorizzazionePDMappingList);
  119.             }
  120.             if (autorizzazionePDList == null) {
  121.                 autorizzazionePDList = new ArrayList<>();
  122.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE, autorizzazionePDList);
  123.             }
  124.             if (autorizzazionePAMappingList == null) {
  125.                 autorizzazionePAMappingList = new ArrayList<>();
  126.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA, autorizzazionePAMappingList);
  127.             }
  128.             if (autorizzazionePAList == null) {
  129.                 autorizzazionePAList = new ArrayList<>();
  130.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_PA, autorizzazionePAList);
  131.             }
  132.             if (autorizzazionePAMappingModiList == null) {
  133.                 autorizzazionePAMappingModiList = new ArrayList<>();
  134.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA_MODI, autorizzazionePAMappingModiList);
  135.             }
  136.             if (autorizzazionePAModiList == null) {
  137.                 autorizzazionePAModiList = new ArrayList<>();
  138.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_PA_MODI, autorizzazionePAModiList);
  139.             }
  140.             
  141.             if (autorizzazioneTokenPDMappingList == null) {
  142.                 autorizzazioneTokenPDMappingList = new ArrayList<>();
  143.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_MAPPING_PD, autorizzazioneTokenPDMappingList);
  144.             }
  145.             if (autorizzazioneTokenPDList == null) {
  146.                 autorizzazioneTokenPDList = new ArrayList<>();
  147.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_PD, autorizzazioneTokenPDList);
  148.             }
  149.             if (autorizzazioneTokenPAMappingList == null) {
  150.                 autorizzazioneTokenPAMappingList = new ArrayList<>();
  151.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_MAPPING_PA, autorizzazioneTokenPAMappingList);
  152.             }
  153.             if (autorizzazioneTokenPAList == null) {
  154.                 autorizzazioneTokenPAList = new ArrayList<>();
  155.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_PA, autorizzazioneTokenPAList);
  156.             }
  157.             
  158.             if (ruoliPDMappingList == null) {
  159.                 ruoliPDMappingList = new ArrayList<>();
  160.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_MAPPING, ruoliPDMappingList);
  161.             }
  162.             if (ruoliPDList == null) {
  163.                 ruoliPDList = new ArrayList<>();
  164.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI, ruoliPDList);
  165.             }
  166.             if (ruoliPAMappingList == null) {
  167.                 ruoliPAMappingList = new ArrayList<>();
  168.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_MAPPING_PA, ruoliPAMappingList);
  169.             }
  170.             if (ruoliPAList == null) {
  171.                 ruoliPAList = new ArrayList<>();
  172.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_PA, ruoliPAList);
  173.             }
  174.             
  175.             if (ruoliTokenPDMappingList == null) {
  176.                 ruoliTokenPDMappingList = new ArrayList<>();
  177.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PD, ruoliPDMappingList);
  178.             }
  179.             if (ruoliTokenPDList == null) {
  180.                 ruoliTokenPDList = new ArrayList<>();
  181.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PD, ruoliTokenPDList);
  182.             }
  183.             if (ruoliTokenPAMappingList == null) {
  184.                 ruoliTokenPAMappingList = new ArrayList<>();
  185.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA, ruoliTokenPAMappingList);
  186.             }
  187.             if (ruoliTokenPAList == null) {
  188.                 ruoliTokenPAList = new ArrayList<>();
  189.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PA, ruoliTokenPAList);
  190.             }
  191.             if (ruoliTokenPAMappingModiList == null) {
  192.                 ruoliTokenPAMappingModiList = new ArrayList<>();
  193.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA_MODI, ruoliTokenPAMappingModiList);
  194.             }
  195.             if (ruoliTokenPAModiList == null) {
  196.                 ruoliTokenPAModiList = new ArrayList<>();
  197.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PA_MODI, ruoliTokenPAModiList);
  198.             }
  199.             
  200.             if (porteApplicativeList == null) {
  201.                 porteApplicativeList = new ArrayList<>();
  202.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porteApplicativeList);
  203.             }
  204.             if (porteApplicativeMappingList == null) {
  205.                 porteApplicativeMappingList = new ArrayList<>();
  206.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, porteApplicativeMappingList);
  207.             }
  208.             if (ctList == null) {
  209.                 ctList = new ArrayList<>();
  210.                 whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ctList);
  211.             }
  212.             if (allarmeList == null) {
  213.                 allarmeList = new ArrayList<>();
  214.                 whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarmeList);
  215.             }
  216.             if (trasformazionePDMappingList == null) {
  217.                 trasformazionePDMappingList = new ArrayList<>();
  218.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PD, trasformazionePDMappingList);
  219.             }
  220.             if (trasformazionePDList == null) {
  221.                 trasformazionePDList = new ArrayList<>();
  222.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PD, trasformazionePDList);
  223.             }
  224.             if (trasformazionePAMappingList == null) {
  225.                 trasformazionePAMappingList = new ArrayList<>();
  226.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA, trasformazionePAMappingList);
  227.             }
  228.             if (trasformazionePAList == null) {
  229.                 trasformazionePAList = new ArrayList<>();
  230.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PA, trasformazionePAList);
  231.             }
  232.             
  233.             if (modiSignalHubList == null) {
  234.                 modiSignalHubList = new ArrayList<>();
  235.                 whereIsInUso.put(ErrorsHandlerCostant.IS_RIFERITA_MODI_SIGNAL_HUB, modiSignalHubList);
  236.             }

  238.             // Porte delegate, autorizzazione
  239.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  240.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_SA);
  241.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  242.             sqlQueryObject.addSelectField("nome_porta");
  243.             sqlQueryObject.setANDLogicOperator(true);
  244.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_SA+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  245.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  246.             queryString = sqlQueryObject.createSQLQuery();
  247.             stmt = con.prepareStatement(queryString);
  248.             stmt.setLong(1, idServizioApplicativoLong);
  249.             risultato = stmt.executeQuery();
  250.             while (risultato.next()){
  251.                 String nome = risultato.getString("nome_porta");
  252.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  253.                 if(resultPorta.mapping) {
  254.                     autorizzazionePDMappingList.add(resultPorta.label);
  255.                 }
  256.                 else {
  257.                     autorizzazionePDList.add(resultPorta.label);
  258.                 }
  259.                 isInUso = true;
  260.             }
  261.             risultato.close();
  262.             stmt.close();
  263.             
  264.             
  265.             // Porte delegate, autorizzazione (token)
  266.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  267.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  268.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  269.             sqlQueryObject.addSelectField("nome_porta");
  270.             sqlQueryObject.setANDLogicOperator(true);
  271.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TOKEN_SA+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  272.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  273.             queryString = sqlQueryObject.createSQLQuery();
  274.             stmt = con.prepareStatement(queryString);
  275.             stmt.setLong(1, idServizioApplicativoLong);
  276.             risultato = stmt.executeQuery();
  277.             while (risultato.next()){
  278.                 String nome = risultato.getString("nome_porta");
  279.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  280.                 if(resultPorta.mapping) {
  281.                     autorizzazioneTokenPDMappingList.add(resultPorta.label);
  282.                 }
  283.                 else {
  284.                     autorizzazioneTokenPDList.add(resultPorta.label);
  285.                 }
  286.                 isInUso = true;
  287.             }
  288.             risultato.close();
  289.             stmt.close();
  290.             
  291.             
  292.             // Porte applicative, autorizzazione
  293.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  294.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA_AUTORIZZATI);
  295.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  296.             sqlQueryObject.addSelectField("nome_porta");
  297.             sqlQueryObject.setANDLogicOperator(true);
  298.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA_AUTORIZZATI+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  299.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  300.             queryString = sqlQueryObject.createSQLQuery();
  301.             stmt = con.prepareStatement(queryString);
  302.             stmt.setLong(1, idServizioApplicativoLong);
  303.             risultato = stmt.executeQuery();
  304.             while (risultato.next()){
  305.                 String nome = risultato.getString("nome_porta");
  306.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  307.                 if(resultPorta.mapping) {
  308.                     if(resultPorta.erogazioneModi)
  309.                         autorizzazionePAMappingModiList.add(resultPorta.label);
  310.                     else
  311.                         autorizzazionePAMappingList.add(resultPorta.label);
  312.                 }
  313.                 else {
  314.                     if(resultPorta.erogazioneModi)
  315.                         autorizzazionePAModiList.add(resultPorta.label);
  316.                     else
  317.                         autorizzazionePAList.add(resultPorta.label);
  318.                 }
  319.                 isInUso = true;
  320.             }
  321.             risultato.close();
  322.             stmt.close();
  323.             
  324.             
  325.             // Porte applicative, autorizzazione (token)
  326.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  327.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TOKEN_SA);
  328.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  329.             sqlQueryObject.addSelectField("nome_porta");
  330.             sqlQueryObject.setANDLogicOperator(true);
  331.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TOKEN_SA+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  332.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  333.             queryString = sqlQueryObject.createSQLQuery();
  334.             stmt = con.prepareStatement(queryString);
  335.             stmt.setLong(1, idServizioApplicativoLong);
  336.             risultato = stmt.executeQuery();
  337.             while (risultato.next()){
  338.                 String nome = risultato.getString("nome_porta");
  339.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  340.                 if(resultPorta.mapping) {
  341.                     autorizzazioneTokenPAMappingList.add(resultPorta.label);
  342.                 }
  343.                 else {
  344.                     autorizzazioneTokenPAList.add(resultPorta.label);
  345.                 }
  346.                 isInUso = true;
  347.             }
  348.             risultato.close();
  349.             stmt.close(); 

  351.             
  352.             
  353.             if(verificaRuoli) {
  354.                 
  355.                 // Raccolgo prima i ruoli
  356.                 List<String> listRuoliSA = new ArrayList<>();
  357.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  358.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  359.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  360.                 sqlQueryObject.addSelectField("ruolo");
  361.                 sqlQueryObject.setANDLogicOperator(true);
  362.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id=?");
  363.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_RUOLI+".id_servizio_applicativo="+CostantiDB.SERVIZI_APPLICATIVI+".id");
  364.                 queryString = sqlQueryObject.createSQLQuery();
  365.                 stmt = con.prepareStatement(queryString);
  366.                 stmt.setLong(1, idServizioApplicativoLong);
  367.                 risultato = stmt.executeQuery();
  368.                 while (risultato.next()){
  369.                     String ruolo = risultato.getString("ruolo");
  370.                     listRuoliSA.add(ruolo);
  371.                 }
  372.                 risultato.close();
  373.                 stmt.close();
  374.                 
  375.                 if(!listRuoliSA.isEmpty()) {
  376.                 
  377.                     checkServizioApplicativoRuoloInUsoInPorteDelegate(con, tipoDB, normalizeObjectIds,
  378.                             CostantiDB.PORTE_DELEGATE_RUOLI,
  379.                             listRuoliSA,
  380.                             ruoliPDMappingList, ruoliPDList);
  381.                     
  382.                     checkServizioApplicativoRuoloInUsoInPorteDelegate(con, tipoDB, normalizeObjectIds,
  383.                             CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI,
  384.                             listRuoliSA,
  385.                             ruoliTokenPDMappingList, ruoliTokenPDList);
  386.                                     
  387.                     boolean isInUsoRuoli = checkServizioApplicativoRuoloInUsoInPorteApplicative(con, tipoDB, normalizeObjectIds,
  388.                             CostantiDB.PORTE_APPLICATIVE_RUOLI,
  389.                             listRuoliSA,
  390.                             ruoliPAMappingList, ruoliPAList,
  391.                             ruoliPAMappingList, ruoliPAList);
  392.                     if(isInUsoRuoli) {
  393.                         isInUso = true;
  394.                     }
  395.                     
  396.                     boolean isInUsoRuoliToken = checkServizioApplicativoRuoloInUsoInPorteApplicative(con, tipoDB, normalizeObjectIds,
  397.                             CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI,
  398.                             listRuoliSA,
  399.                             ruoliTokenPAMappingList, ruoliTokenPAList,
  400.                             ruoliTokenPAMappingModiList, ruoliTokenPAModiList);
  401.                     if(isInUsoRuoliToken) {
  402.                         isInUso = true;
  403.                     }
  404.                 }
  405.             }
  406.             


  409.             // Porte applicative
  410.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  411.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  412.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  413.             sqlQueryObject.addSelectField("*");
  414.             sqlQueryObject.setANDLogicOperator(true);
  415.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  416.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  417.             queryString = sqlQueryObject.createSQLQuery();
  418.             stmt = con.prepareStatement(queryString);
  419.             stmt.setLong(1, idServizioApplicativoLong);
  420.             risultato = stmt.executeQuery();
  421.             while (risultato.next()){
  422.                 String nome = risultato.getString("nome_porta");
  423.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  424.                 if(resultPorta.mapping) {
  425.                     porteApplicativeMappingList.add(resultPorta.label);
  426.                 }
  427.                 else {
  428.                     porteApplicativeList.add(resultPorta.label);
  429.                 }
  430.                 isInUso = true;
  431.             }
  432.             risultato.close();
  433.             stmt.close();

  435.             
  436.             // Controllo che il servizio aplicativo non sia associato a policy di controllo del traffico o allarmi
  437.             
  438.             int max = 2;
  439.             if(!CostantiDB.isAllarmiEnabled()) {
  440.                 max=1;
  441.             }
  442.             for (int i = 0; i < max; i++) {
  443.                 
  444.                 String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  445.                 String identificativo_column = "active_policy_id";
  446.                 String alias_column = "policy_alias";
  447.                 List<String> list = ctList;
  448.                 String oggetto = "Policy";
  449.                 boolean allarmi = false;
  450.                 if(i==1) {
  451.                     tabella = CostantiDB.ALLARMI;
  452.                     identificativo_column = "nome";
  453.                     alias_column = "alias";
  454.                     list = allarmeList;
  455.                     oggetto = "Allarme";
  456.                     allarmi=true;
  457.                 }
  458.                 
  459.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  460.                 sqlQueryObject.addFromTable(tabella);
  461.                 sqlQueryObject.addSelectField(identificativo_column);
  462.                 sqlQueryObject.addSelectField(alias_column);
  463.                 sqlQueryObject.addSelectField("filtro_ruolo");
  464.                 sqlQueryObject.addSelectField("filtro_porta");
  465.                 sqlQueryObject.setANDLogicOperator(false); // OR
  466.                 sqlQueryObject.addWhereCondition(true, 
  467.                         tabella+".filtro_tipo_fruitore = ?", 
  468.                         tabella+".filtro_nome_fruitore = ?",
  469.                         tabella+".filtro_sa_fruitore = ?");
  470.                 if(!allarmi) {
  471.                     sqlQueryObject.addWhereCondition(true, 
  472.                             tabella+".filtro_tipo_erogatore = ?", 
  473.                             tabella+".filtro_nome_erogatore = ?",
  474.                             tabella+".filtro_sa_erogatore = ?");
  475.                 }
  476.                 sqlQueryObject.addOrderBy("filtro_ruolo");
  477.                 sqlQueryObject.addOrderBy("filtro_porta");
  478.                 queryString = sqlQueryObject.createSQLQuery();
  479.                 stmt = con.prepareStatement(queryString);
  480.                 int index = 1;
  481.                 stmt.setString(index++, idServizioApplicativo.getIdSoggettoProprietario().getTipo());
  482.                 stmt.setString(index++, idServizioApplicativo.getIdSoggettoProprietario().getNome());
  483.                 stmt.setString(index++, idServizioApplicativo.getNome());
  484.                 if(!allarmi) {
  485.                     stmt.setString(index++, idServizioApplicativo.getIdSoggettoProprietario().getTipo());
  486.                     stmt.setString(index++, idServizioApplicativo.getIdSoggettoProprietario().getNome());
  487.                     stmt.setString(index++, idServizioApplicativo.getNome());
  488.                 }
  489.                 risultato = stmt.executeQuery();
  490.                 while (risultato.next()) {
  491.                     
  492.                     String alias = risultato.getString(alias_column);
  493.                     if(alias== null || "".equals(alias)) {
  494.                         alias = risultato.getString(identificativo_column);
  495.                     }
  496.                     
  497.                     String nomePorta = risultato.getString("filtro_porta");
  498.                     String filtro_ruolo = risultato.getString("filtro_ruolo");
  499.                     if(nomePorta!=null) {
  500.                         String tipo = null;
  501.                         String label = null;
  502.                         if("delegata".equals(filtro_ruolo)) {
  503.                             try {
  504.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  505.                                 if(resultPorta.mapping) {
  506.                                     label = "Fruizione di Servizio "+ resultPorta.label;
  507.                                 }
  508.                             }catch(Exception e) {
  509.                                 tipo = "Outbound";
  510.                             }
  511.                         }
  512.                         else if("applicativa".equals(filtro_ruolo)) {
  513.                             try {
  514.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  515.                                 if(resultPorta.mapping) {
  516.                                     label = "Erogazione di Servizio "+ resultPorta.label;
  517.                                 }
  518.                             }catch(Exception e) {
  519.                                 tipo = "Inbound";
  520.                             }
  521.                         }
  522.                         else {
  523.                             tipo = filtro_ruolo;
  524.                         }
  525.                         if(label==null) {
  526.                             list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  527.                         }
  528.                         else {
  529.                             list.add(oggetto+" '"+alias+"' attiva nella "+label);
  530.                         }
  531.                     }
  532.                     else {
  533.                         list.add(oggetto+" '"+alias+"'");
  534.                     }
  535.     
  536.                     isInUso = true;
  537.                 }
  538.                 risultato.close();
  539.                 stmt.close();
  540.             }
  541.             
  542.             
  543.             
  544.             // Porte delegate, trasformazioni
  545.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  546.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA);
  547.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI);
  548.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  549.             sqlQueryObject.addSelectField("nome_porta");
  550.             sqlQueryObject.setANDLogicOperator(true);
  551.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  552.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA+".id_trasformazione="+CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id");
  553.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  554.             queryString = sqlQueryObject.createSQLQuery();
  555.             stmt = con.prepareStatement(queryString);
  556.             stmt.setLong(1, idServizioApplicativoLong);
  557.             risultato = stmt.executeQuery();
  558.             while (risultato.next()){
  559.                 String nome = risultato.getString("nome_porta");
  560.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  561.                 if(resultPorta.mapping) {
  562.                     trasformazionePDMappingList.add(resultPorta.label);
  563.                 }
  564.                 else {
  565.                     trasformazionePDList.add(resultPorta.label);
  566.                 }
  567.                 isInUso = true;
  568.             }
  569.             risultato.close();
  570.             stmt.close();
  571.             
  572.             
  573.             
  574.             // Porte applicative, trasformazioni
  575.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  576.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA);
  577.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI);
  578.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  579.             sqlQueryObject.addSelectField("nome_porta");
  580.             sqlQueryObject.setANDLogicOperator(true);
  581.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  582.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA+".id_trasformazione="+CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id");
  583.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  584.             queryString = sqlQueryObject.createSQLQuery();
  585.             stmt = con.prepareStatement(queryString);
  586.             stmt.setLong(1, idServizioApplicativoLong);
  587.             risultato = stmt.executeQuery();
  588.             while (risultato.next()){
  589.                 String nome = risultato.getString("nome_porta");
  590.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  591.                 if(resultPorta.mapping) {
  592.                     trasformazionePAMappingList.add(resultPorta.label);
  593.                 }
  594.                 else {
  595.                     trasformazionePAList.add(resultPorta.label);
  596.                 }
  597.                 isInUso = true;
  598.             }
  599.             risultato.close();
  600.             stmt.close();
  601.             
  602.             
  603.             
  604.             
  605.             // ** Controllo che non sia riferito dalla configurazione SignalHub **      
  606.             
  607.             
  608.             if(Costanti.MODIPA_PROTOCOL_NAME.equals(idServizioApplicativo.getIdSoggettoProprietario().getTipo())) {
  609.             
  610.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  611.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  612.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  613.                 sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  614.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI,"tipo_servizio","tipoServizio");
  615.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI,"nome_servizio","nomeServizio");
  616.                 sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI,"versione_servizio","versioneServizio");
  617.                 sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"tipo_soggetto","tipoSoggetto");
  618.                 sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"nome_soggetto","nomeSoggetto");
  619.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI + ".id_soggetto = " + CostantiDB.SOGGETTI + ".id");
  620.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  621.                 sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  622.                 sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  623.                 sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  624.                 sqlQueryObject.setANDLogicOperator(true);
  625.                 queryString = sqlQueryObject.createSQLQuery();
  626.                 stmt = con.prepareStatement(queryString);
  627.                 int index = 1;
  628.                 stmt.setString(index++, ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA.name());
  629.                 stmt.setString(index++, CostantiDB.MODIPA_API_IMPL_INFO_SIGNAL_HUB_PUBLISHER_SA_ID);
  630.                 stmt.setString(index++, idServizioApplicativo.getNome());
  631.                 risultato = stmt.executeQuery();
  632.                 while(risultato.next()) {
  633.                     
  634.                     IDServizio idS = IDServizioFactory.getInstance().getIDServizioFromValues(risultato.getString("tipoServizio"), risultato.getString("nomeServizio"), 
  635.                             risultato.getString("tipoSoggetto"), risultato.getString("nomeSoggetto"), 
  636.                             risultato.getInt("versioneServizio"));
  637.                     
  638.                     // trovata
  639.                     IDPortaApplicativa idPA = DBMappingUtils.getIDPortaApplicativaAssociataDefault(idS, con, tipoDB);
  640.                     if(idPA!=null) {
  641.                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(idPA.getNome(), tipoDB, con, normalizeObjectIds);
  642.                         modiSignalHubList.add(resultPorta.label);
  643.                     }
  644.                     else {
  645.                         modiSignalHubList.add(idS.toString());
  646.                     }
  647.                     
  648.                     isInUso = true;
  649.                     
  650.                 }
  651.                 risultato.close();
  652.                 stmt.close();
  653.                     
  654.             }
  655.             
  656.             
  657.             return isInUso;

  659.         } catch (Exception se) {
  660.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  661.         } finally {
  662.             // Chiudo statement and resultset
  663.             JDBCUtilities.closeResources(risultato2, stmt2);
  664.             JDBCUtilities.closeResources(risultato, stmt);
  665.         }
  666.     }
  667.     
  668.     private static boolean checkServizioApplicativoRuoloInUsoInPorteDelegate(Connection con, String tipoDB, boolean normalizeObjectIds,
  669.             String nomeTabella,
  670.             List<String> listRuoliSA,
  671.             List<String> ruoliPDmappingList, List<String> ruoliPDlist) throws Exception {
  672.         boolean isInUso = false;
  673.         PreparedStatement stmt = null;
  674.         ResultSet risultato = null;
  675.         try {
  676.             
  677.             List<String> distinctPorteDelegate = new ArrayList<>();
  678.             List<String> verificaPorteDelegateAll = new ArrayList<>();
  679.             
  680.             for (String ruolo : listRuoliSA) {
  681.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  682.                 sqlQueryObject.addFromTable(nomeTabella);
  683.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  684.                 sqlQueryObject.addSelectField("nome_porta");
  685.                 sqlQueryObject.addSelectField("ruoli_match");
  686.                 sqlQueryObject.setANDLogicOperator(true);
  687.                 sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  688.                 sqlQueryObject.addWhereCondition(nomeTabella+".ruolo=?");
  689.                 String queryString = sqlQueryObject.createSQLQuery();
  690.                 stmt = con.prepareStatement(queryString);
  691.                 stmt.setString(1, ruolo);
  692.                 risultato = stmt.executeQuery();
  693.                 while (risultato.next()){
  694.                     String nome = risultato.getString("nome_porta");
  695.                     String ruoloMatch = risultato.getString("ruoli_match");
  696.                     if(RuoloTipoMatch.ANY.getValue().equals(ruoloMatch)) {
  697.                         if(distinctPorteDelegate.contains(nome)) {
  698.                             continue;
  699.                         }
  700.                         else {
  701.                             distinctPorteDelegate.add(nome);
  702.                         }
  703.                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  704.                         if(resultPorta.mapping) {
  705.                             ruoliPDmappingList.add(resultPorta.label);
  706.                         }
  707.                         else {
  708.                             ruoliPDlist.add(resultPorta.label);
  709.                         }
  710.                         isInUso = true;
  711.                     }
  712.                     else {
  713.                         // devo verificare tutti i ruoli richiesti
  714.                         if(verificaPorteDelegateAll.contains(nome)) {
  715.                             continue;
  716.                         }
  717.                         else {
  718.                             verificaPorteDelegateAll.add(nome);
  719.                         }
  720.                     }
  721.                 }
  722.                 risultato.close();
  723.                 stmt.close();   
  724.             }
  725.             
  726.             // autorizzazione 'all'
  727.             if(!verificaPorteDelegateAll.isEmpty()) {
  728.                 for (String nome : verificaPorteDelegateAll) {
  729.                     
  730.                     // Raccolgo prima i ruoli della porta
  731.                     List<String> listRuoliPorta = new ArrayList<>();
  732.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  733.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  734.                     sqlQueryObject.addFromTable(nomeTabella);
  735.                     sqlQueryObject.addSelectField("ruolo");
  736.                     sqlQueryObject.setANDLogicOperator(true);
  737.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta=?");
  738.                     sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  739.                     String queryString = sqlQueryObject.createSQLQuery();
  740.                     stmt = con.prepareStatement(queryString);
  741.                     stmt.setString(1, nome);
  742.                     risultato = stmt.executeQuery();
  743.                     while (risultato.next()){
  744.                         String ruolo = risultato.getString("ruolo");
  745.                         listRuoliPorta.add(ruolo);
  746.                     }
  747.                     risultato.close();
  748.                     stmt.close();
  749.                     
  750.                     if(!listRuoliPorta.isEmpty()) {
  751.                         boolean match = true;
  752.                         for (String ruoloPorta : listRuoliPorta) {
  753.                             if(!listRuoliSA.contains(ruoloPorta)) {
  754.                                 match = false;
  755.                                 break;
  756.                             }
  757.                         }
  758.                         if(match) {
  759.                             if(distinctPorteDelegate.contains(nome)) {
  760.                                 continue;
  761.                             }
  762.                             else {
  763.                                 distinctPorteDelegate.add(nome);
  764.                             }
  765.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  766.                             if(resultPorta.mapping) {
  767.                                 ruoliPDmappingList.add(resultPorta.label);
  768.                             }
  769.                             else {
  770.                                 ruoliPDlist.add(resultPorta.label);
  771.                             }
  772.                             isInUso = true;
  773.                         }
  774.                     }
  775.                     
  776.                 }
  777.             }
  778.             
  779.             
  780.             
  781.         } finally {
  782.             // Chiudo statement and resultset
  783.             try {
  784.                 if (risultato != null) {
  785.                     risultato.close();
  786.                 }
  787.             } catch (Exception e) {
  788.                 // ignore
  789.             }
  790.             try {
  791.                 if (stmt != null) {
  792.                     stmt.close();
  793.                 }
  794.             } catch (Exception e) {
  795.                 // ignore
  796.             }
  797.         }
  798.         return isInUso;
  799.     }
  800.     
  801.     private static boolean checkServizioApplicativoRuoloInUsoInPorteApplicative(Connection con, String tipoDB, boolean normalizeObjectIds,
  802.             String nomeTabella,
  803.             List<String> listRuoliSA,
  804.             List<String> ruoliPAmappingList, List<String> ruoliPAlist,
  805.             List<String> ruoliPAmappingModiList, List<String> ruoliPAmodiList) throws Exception {
  806.         boolean isInUso = false;
  807.         PreparedStatement stmt = null;
  808.         ResultSet risultato = null;
  809.         try {
  810.             
  811.             List<String> distinctPorteApplicative = new ArrayList<>();
  812.             List<String> verificaPorteApplicativeAll = new ArrayList<>();
  813.             
  814.             for (String ruolo : listRuoliSA) {
  815.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  816.                 sqlQueryObject.addFromTable(nomeTabella);
  817.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  818.                 sqlQueryObject.addSelectField("nome_porta");
  819.                 sqlQueryObject.addSelectField("ruoli_match");
  820.                 sqlQueryObject.setANDLogicOperator(true);
  821.                 sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  822.                 sqlQueryObject.addWhereCondition(nomeTabella+".ruolo=?");
  823.                 String queryString = sqlQueryObject.createSQLQuery();
  824.                 stmt = con.prepareStatement(queryString);
  825.                 stmt.setString(1, ruolo);
  826.                 risultato = stmt.executeQuery();
  827.                 while (risultato.next()){
  828.                     String nome = risultato.getString("nome_porta");
  829.                     String ruoloMatch = risultato.getString("ruoli_match");
  830.                     if(RuoloTipoMatch.ANY.getValue().equals(ruoloMatch)) {
  831.                         if(distinctPorteApplicative.contains(nome)) {
  832.                             continue;
  833.                         }
  834.                         else {
  835.                             distinctPorteApplicative.add(nome);
  836.                         }
  837.                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  838.                         if(resultPorta.mapping) {
  839.                             if(resultPorta.erogazioneModi)
  840.                                 ruoliPAmappingModiList.add(resultPorta.label);
  841.                             else
  842.                                 ruoliPAmappingList.add(resultPorta.label);
  843.                         }
  844.                         else {
  845.                             if(resultPorta.erogazioneModi)
  846.                                 ruoliPAmodiList.add(resultPorta.label);
  847.                             else
  848.                                 ruoliPAlist.add(resultPorta.label);
  849.                         }
  850.                         isInUso = true;
  851.                     }
  852.                     else {
  853.                         // devo verificare tutti i ruoli richiesti
  854.                         if(verificaPorteApplicativeAll.contains(nome)) {
  855.                             continue;
  856.                         }
  857.                         else {
  858.                             verificaPorteApplicativeAll.add(nome);
  859.                         }
  860.                     }
  861.                 }
  862.                 risultato.close();
  863.                 stmt.close();   
  864.             }
  865.             
  866.             // autorizzazione 'all'
  867.             if(!verificaPorteApplicativeAll.isEmpty()) {
  868.                 for (String nome : verificaPorteApplicativeAll) {
  869.                     
  870.                     // Raccolgo prima i ruoli della porta
  871.                     List<String> listRuoliPorta = new ArrayList<>();
  872.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  873.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  874.                     sqlQueryObject.addFromTable(nomeTabella);
  875.                     sqlQueryObject.addSelectField("ruolo");
  876.                     sqlQueryObject.setANDLogicOperator(true);
  877.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta=?");
  878.                     sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  879.                     String queryString = sqlQueryObject.createSQLQuery();
  880.                     stmt = con.prepareStatement(queryString);
  881.                     stmt.setString(1, nome);
  882.                     risultato = stmt.executeQuery();
  883.                     while (risultato.next()){
  884.                         String ruolo = risultato.getString("ruolo");
  885.                         listRuoliPorta.add(ruolo);
  886.                     }
  887.                     risultato.close();
  888.                     stmt.close();
  889.                     
  890.                     if(!listRuoliPorta.isEmpty()) {
  891.                         boolean match = true;
  892.                         for (String ruoloPorta : listRuoliPorta) {
  893.                             if(!listRuoliSA.contains(ruoloPorta)) {
  894.                                 match = false;
  895.                                 break;
  896.                             }
  897.                         }
  898.                         if(match) {
  899.                             if(distinctPorteApplicative.contains(nome)) {
  900.                                 continue;
  901.                             }
  902.                             else {
  903.                                 distinctPorteApplicative.add(nome);
  904.                             }
  905.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  906.                             if(resultPorta.mapping) {
  907.                                 if(resultPorta.erogazioneModi)
  908.                                     ruoliPAmappingModiList.add(resultPorta.label);
  909.                                 else
  910.                                     ruoliPAmappingList.add(resultPorta.label);
  911.                             }
  912.                             else {
  913.                                 if(resultPorta.erogazioneModi)
  914.                                     ruoliPAmodiList.add(resultPorta.label);
  915.                                 else
  916.                                     ruoliPAlist.add(resultPorta.label);
  917.                             }
  918.                             isInUso = true;
  919.                         }
  920.                     }
  921.                     
  922.                 }
  923.             }
  924.         } finally {
  925.             // Chiudo statement and resultset
  926.             try {
  927.                 if (risultato != null) {
  928.                     risultato.close();
  929.                 }
  930.             } catch (Exception e) {
  931.                 // ignore
  932.             }
  933.             try {
  934.                 if (stmt != null) {
  935.                     stmt.close();
  936.                 }
  937.             } catch (Exception e) {
  938.                 // ignore
  939.             }
  940.         }
  941.         return isInUso;
  942.     }

  944.     protected static String toString(IDServizioApplicativo idServizioApplicativo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, boolean normalizeObjectIds){
  945.         
  946.         StringBuilder bf = new StringBuilder();
  947.         if(normalizeObjectIds) {
  948.             try {
  949.                 String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idServizioApplicativo.getIdSoggettoProprietario().getTipo());
  950.                 String labelSA = DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+idServizioApplicativo.getNome()+DBOggettiInUsoUtils.getSubjectSuffix(protocollo, idServizioApplicativo.getIdSoggettoProprietario());
  951.                 bf.append(labelSA);
  952.             }catch(Exception e) {
  953.                 bf.append(idServizioApplicativo.getIdSoggettoProprietario().toString()+"_"+idServizioApplicativo.getNome());
  954.             }
  955.         }
  956.         else {
  957.             bf.append(idServizioApplicativo.getIdSoggettoProprietario().toString()+"_"+idServizioApplicativo.getNome());
  958.         }
  959.         
  960.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  961.         StringBuilder msgBuilder = new StringBuilder("Applicativo '" +bf.toString() +"' non eliminabile perch&egrave; :"+separator);
  962.         if(!prefix){
  963.             msgBuilder = new StringBuilder("");
  964.         }
  965.         String separatorCategorie = "";
  966.         if(whereIsInUso.size()>1) {
  967.             separatorCategorie = separator;
  968.         }
  969.         for (ErrorsHandlerCostant key : keys) {
  970.             List<String> messages = whereIsInUso.get(key);

  972.             if ( messages!=null && !messages.isEmpty()) {
  973.                 msgBuilder.append(separatorCategorie);
  974.             }
  975.             
  976.             switch (key) {
  977.             case AUTORIZZAZIONE_MAPPING:
  978.                 if ( messages!=null && !messages.isEmpty()) {
  979.                     msgBuilder.append("utilizzato nel Controllo degli Accessi (Autorizzazione Trasporto - Richiedenti Autorizzati) delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  980.                 }
  981.                 break;
  982.             case AUTORIZZAZIONE:
  983.                 if ( messages!=null && !messages.isEmpty()) {
  984.                     msgBuilder.append("utilizzato nelle Porte Outbound (Controllo degli Accessi - Autorizzazione Trasporto -  Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  985.                 }
  986.                 break;
  987.             case AUTORIZZAZIONE_MAPPING_PA:
  988.                 if ( messages!=null && !messages.isEmpty()) {
  989.                     msgBuilder.append("utilizzato nel Controllo degli Accessi (Autorizzazione Trasporto - Richiedenti Autorizzati) delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  990.                 }
  991.                 break;
  992.             case AUTORIZZAZIONE_PA:
  993.                 if ( messages!=null && !messages.isEmpty()) {
  994.                     msgBuilder.append("utilizzato nelle Porte Inbound (Controllo degli Accessi - Autorizzazione Trasporto - Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  995.                 }
  996.                 break;
  997.             case AUTORIZZAZIONE_MAPPING_PA_MODI:
  998.                 if ( messages!=null && !messages.isEmpty()) {
  999.                     msgBuilder.append("utilizzato nel Controllo degli Accessi (Autorizzazione Messaggio - Richiedenti Autorizzati) delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1000.                 }
  1001.                 break;
  1002.             case AUTORIZZAZIONE_PA_MODI:
  1003.                 if ( messages!=null && !messages.isEmpty()) {
  1004.                     msgBuilder.append("utilizzato nelle Porte Inbound (Controllo degli Accessi - Autorizzazione Messaggio - Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1005.                 }
  1006.                 break;
  1007.                 
  1008.             case AUTORIZZAZIONE_TOKEN_MAPPING_PD:
  1009.                 if ( messages!=null && !messages.isEmpty()) {
  1010.                     msgBuilder.append("utilizzato nel Controllo degli Accessi (Autorizzazione Token - Richiedenti Autorizzati) delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1011.                 }
  1012.                 break;
  1013.             case AUTORIZZAZIONE_TOKEN_PD:
  1014.                 if ( messages!=null && !messages.isEmpty()) {
  1015.                     msgBuilder.append("utilizzato nelle Porte Outbound (Controllo degli Accessi - Autorizzazione Token - Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1016.                 }
  1017.                 break;
  1018.             case AUTORIZZAZIONE_TOKEN_MAPPING_PA:
  1019.                 if ( messages!=null && !messages.isEmpty()) {
  1020.                     msgBuilder.append("utilizzato nel Controllo degli Accessi (Autorizzazione Token - Richiedenti Autorizzati) delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1021.                 }
  1022.                 break;
  1023.             case AUTORIZZAZIONE_TOKEN_PA:
  1024.                 if ( messages!=null && !messages.isEmpty()) {
  1025.                     msgBuilder.append("utilizzato nelle Porte Inbound (Controllo degli Accessi - Autorizzazione Token - Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1026.                 }
  1027.                 break;
  1028.                 
  1029.             case RUOLI_MAPPING:
  1030.                 if ( messages!=null && !messages.isEmpty()) {
  1031.                     msgBuilder.append("compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1032.                 }
  1033.                 break;
  1034.             case RUOLI:
  1035.                 if ( messages!=null && !messages.isEmpty()) {
  1036.                     msgBuilder.append("compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Porte Outbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1037.                 }
  1038.                 break;
  1039.             case RUOLI_MAPPING_PA:
  1040.                 if ( messages!=null && !messages.isEmpty()) {
  1041.                     msgBuilder.append("compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1042.                 }
  1043.                 break;
  1044.             case RUOLI_PA:
  1045.                 if ( messages!=null && !messages.isEmpty()) {
  1046.                     msgBuilder.append("compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1047.                 }
  1048.                 break;
  1049.                 
  1050.             case RUOLI_TOKEN_MAPPING_PD:
  1051.                 if ( messages!=null && !messages.isEmpty()) {
  1052.                     msgBuilder.append("compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1053.                 }
  1054.                 break;
  1055.             case RUOLI_TOKEN_PD:
  1056.                 if ( messages!=null && !messages.isEmpty()) {
  1057.                     msgBuilder.append("compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Porte Outbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1058.                 }
  1059.                 break;
  1060.             case RUOLI_TOKEN_MAPPING_PA:
  1061.                 if ( messages!=null && !messages.isEmpty()) {
  1062.                     msgBuilder.append("compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1063.                 }
  1064.                 break;
  1065.             case RUOLI_TOKEN_PA:
  1066.                 if ( messages!=null && !messages.isEmpty()) {
  1067.                     msgBuilder.append("compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1068.                 }
  1069.                 break;
  1070.             case RUOLI_TOKEN_MAPPING_PA_MODI:
  1071.                 if ( messages!=null && !messages.isEmpty()) {
  1072.                     msgBuilder.append("compatibile con l'Autorizzazione Messaggio per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1073.                 }
  1074.                 break;
  1075.             case RUOLI_TOKEN_PA_MODI:
  1076.                 if ( messages!=null && !messages.isEmpty()) {
  1077.                     msgBuilder.append("compatibile con l'Autorizzazione Messaggio per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1078.                 }
  1079.                 break;
  1080.                 
  1081.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  1082.                 if ( messages!=null && !messages.isEmpty()) {
  1083.                     msgBuilder.append("utilizzato come applicativo server nei connettori delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1084.                 }
  1085.                 break;
  1086.             case IN_USO_IN_PORTE_APPLICATIVE:
  1087.                 if ( messages!=null && !messages.isEmpty()) {
  1088.                     msgBuilder.append("in uso in Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1089.                 }
  1090.                 break;
  1091.             case CONTROLLO_TRAFFICO:
  1092.                 if ( messages!=null && !messages.isEmpty()) {
  1093.                     msgBuilder.append("utilizzato in policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1094.                 }
  1095.                 break;
  1096.             case ALLARMI:
  1097.                 if ( messages!=null && !messages.isEmpty()) {
  1098.                     msgBuilder.append("utilizzato in Allarmi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1099.                 }
  1100.                 break;
  1101.             case TRASFORMAZIONE_MAPPING_PD:
  1102.                 if ( messages!=null && !messages.isEmpty()) {
  1103.                     msgBuilder.append("utilizzato nel criterio di applicabilità della Trasformazione (Applicativi) per le Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1104.                 }
  1105.                 break;
  1106.             case TRASFORMAZIONE_PD:
  1107.                 if ( messages!=null && !messages.isEmpty()) {
  1108.                     msgBuilder.append("utilizzato nelle Porte Outbound (Criterio di applicabilità della Trasformazione - Applicativi): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1109.                 }
  1110.                 break;
  1111.             case TRASFORMAZIONE_MAPPING_PA:
  1112.                 if ( messages!=null && !messages.isEmpty()) {
  1113.                     msgBuilder.append("utilizzato nel criterio di applicabilità della Trasformazione (Applicativi) per le Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1114.                 }
  1115.                 break;
  1116.             case TRASFORMAZIONE_PA:
  1117.                 if ( messages!=null && !messages.isEmpty()) {
  1118.                     msgBuilder.append("utilizzato nelle Porte Inbound (Criterio di applicabilità della Trasformazione - Applicativi): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1119.                 }
  1120.                 break;
  1121.                 
  1122.             case IS_RIFERITA_MODI_SIGNAL_HUB:
  1123.                 if ( messages!=null && !messages.isEmpty() ) {
  1124.                     msgBuilder.append("riferito nella configurazione 'SignalHub' dell'erogazione: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1125.                 }
  1126.                 break;              
  1127.                 
  1128.             default:
  1129.                 msgBuilder.append("utilizzato in oggetto non codificato ("+key+")"+separator);
  1130.                 break;
  1131.             }

  1133.         }// chiudo for

  1135.         return msgBuilder.toString();
  1136.     }
  1137.     
  1138. }
Created with JaCoCo 0.8.8.202204050719