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.id.IDServizioApplicativo;
  36. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  37. import org.openspcoop2.utils.UtilsException;
  38. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  39. import org.openspcoop2.utils.sql.ISQLQueryObject;
  40. import org.openspcoop2.utils.sql.SQLObjectFactory;

  42. /**
  43.  * DBOggettiInUsoUtils_serviziApplicativi
  44.  * 
  45.  * @author Andrea Poli (apoli@link.it)
  46.  * @author $Author$
  47.  * @version $Rev$, $Date$
  48.  * 
  49.  */
  50. public class DBOggettiInUsoUtils_serviziApplicativi {


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

  57.         String nomeMetodo = "isServizioApplicativoInUso";

  59.         PreparedStatement stmt = null;
  60.         ResultSet risultato = null;
  61.         PreparedStatement stmt2 = null;
  62.         ResultSet risultato2 = null;
  63.         String queryString;
  64.         try {
  65.             boolean isInUso = false;

  67.             long idServizioApplicativoLong = DBUtils.getIdServizioApplicativo(idServizioApplicativo.getNome(), 
  68.                     idServizioApplicativo.getIdSoggettoProprietario().getTipo(), 
  69.                     idServizioApplicativo.getIdSoggettoProprietario().getNome(), 
  70.                     con, tipoDB);
  71.             if(idServizioApplicativoLong<=0){
  72.                 throw new UtilsException("Servizio Applicativo con id ["+idServizioApplicativo+"] non trovato");
  73.             }


  76.             List<String> autorizzazionePD_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING);
  77.             List<String> autorizzazionePD_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE);
  78.             List<String> autorizzazionePA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA);
  79.             List<String> autorizzazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_PA);
  80.             List<String> autorizzazionePA_mapping_modi_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA_MODI);
  81.             List<String> autorizzazionePA_modi_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_PA_MODI);
  82.             List<String> autorizzazioneTokenPD_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_MAPPING_PD);
  83.             List<String> autorizzazioneTokenPD_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_PD);
  84.             List<String> autorizzazioneTokenPA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_MAPPING_PA);
  85.             List<String> autorizzazioneTokenPA_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_PA);
  86.             List<String> ruoliPD_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_MAPPING);
  87.             List<String> ruoliPD_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI);
  88.             List<String> ruoliPA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_MAPPING_PA);
  89.             List<String> ruoliPA_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_PA);
  90.             List<String> ruoliTokenPD_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PD);
  91.             List<String> ruoliTokenPD_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PD);
  92.             List<String> ruoliTokenPA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA);
  93.             List<String> ruoliTokenPA_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PA);
  94.             List<String> ruoliTokenPA_mapping_modi_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA_MODI);
  95.             List<String> ruoliTokenPA_modi_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PA_MODI);
  96.             List<String> porte_applicative_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  97.             List<String> porte_applicative_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  98.             List<String> ct_list = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  99.             List<String> allarme_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI);
  100.             List<String> trasformazionePD_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PD);
  101.             List<String> trasformazionePD_list = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PD);
  102.             List<String> trasformazionePA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA);
  103.             List<String> trasformazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PA);
  104.             
  105.             if (autorizzazionePD_mapping_list == null) {
  106.                 autorizzazionePD_mapping_list = new ArrayList<>();
  107.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING, autorizzazionePD_mapping_list);
  108.             }
  109.             if (autorizzazionePD_list == null) {
  110.                 autorizzazionePD_list = new ArrayList<>();
  111.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE, autorizzazionePD_list);
  112.             }
  113.             if (autorizzazionePA_mapping_list == null) {
  114.                 autorizzazionePA_mapping_list = new ArrayList<>();
  115.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA, autorizzazionePA_mapping_list);
  116.             }
  117.             if (autorizzazionePA_list == null) {
  118.                 autorizzazionePA_list = new ArrayList<>();
  119.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_PA, autorizzazionePA_list);
  120.             }
  121.             if (autorizzazionePA_mapping_modi_list == null) {
  122.                 autorizzazionePA_mapping_modi_list = new ArrayList<>();
  123.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA_MODI, autorizzazionePA_mapping_modi_list);
  124.             }
  125.             if (autorizzazionePA_modi_list == null) {
  126.                 autorizzazionePA_modi_list = new ArrayList<>();
  127.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_PA_MODI, autorizzazionePA_modi_list);
  128.             }
  129.             
  130.             if (autorizzazioneTokenPD_mapping_list == null) {
  131.                 autorizzazioneTokenPD_mapping_list = new ArrayList<>();
  132.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_MAPPING_PD, autorizzazioneTokenPD_mapping_list);
  133.             }
  134.             if (autorizzazioneTokenPD_list == null) {
  135.                 autorizzazioneTokenPD_list = new ArrayList<>();
  136.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_PD, autorizzazioneTokenPD_list);
  137.             }
  138.             if (autorizzazioneTokenPA_mapping_list == null) {
  139.                 autorizzazioneTokenPA_mapping_list = new ArrayList<>();
  140.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_MAPPING_PA, autorizzazioneTokenPA_mapping_list);
  141.             }
  142.             if (autorizzazioneTokenPA_list == null) {
  143.                 autorizzazioneTokenPA_list = new ArrayList<>();
  144.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_TOKEN_PA, autorizzazioneTokenPA_list);
  145.             }
  146.             
  147.             if (ruoliPD_mapping_list == null) {
  148.                 ruoliPD_mapping_list = new ArrayList<>();
  149.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_MAPPING, ruoliPD_mapping_list);
  150.             }
  151.             if (ruoliPD_list == null) {
  152.                 ruoliPD_list = new ArrayList<>();
  153.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI, ruoliPD_list);
  154.             }
  155.             if (ruoliPA_mapping_list == null) {
  156.                 ruoliPA_mapping_list = new ArrayList<>();
  157.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_MAPPING_PA, ruoliPA_mapping_list);
  158.             }
  159.             if (ruoliPA_list == null) {
  160.                 ruoliPA_list = new ArrayList<>();
  161.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_PA, ruoliPA_list);
  162.             }
  163.             
  164.             if (ruoliTokenPD_mapping_list == null) {
  165.                 ruoliTokenPD_mapping_list = new ArrayList<>();
  166.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PD, ruoliPD_mapping_list);
  167.             }
  168.             if (ruoliTokenPD_list == null) {
  169.                 ruoliTokenPD_list = new ArrayList<>();
  170.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PD, ruoliTokenPD_list);
  171.             }
  172.             if (ruoliTokenPA_mapping_list == null) {
  173.                 ruoliTokenPA_mapping_list = new ArrayList<>();
  174.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA, ruoliTokenPA_mapping_list);
  175.             }
  176.             if (ruoliTokenPA_list == null) {
  177.                 ruoliTokenPA_list = new ArrayList<>();
  178.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PA, ruoliTokenPA_list);
  179.             }
  180.             if (ruoliTokenPA_mapping_modi_list == null) {
  181.                 ruoliTokenPA_mapping_modi_list = new ArrayList<>();
  182.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA_MODI, ruoliTokenPA_mapping_modi_list);
  183.             }
  184.             if (ruoliTokenPA_modi_list == null) {
  185.                 ruoliTokenPA_modi_list = new ArrayList<>();
  186.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PA_MODI, ruoliTokenPA_modi_list);
  187.             }
  188.             
  189.             if (porte_applicative_list == null) {
  190.                 porte_applicative_list = new ArrayList<>();
  191.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porte_applicative_list);
  192.             }
  193.             if (porte_applicative_mapping_list == null) {
  194.                 porte_applicative_mapping_list = new ArrayList<>();
  195.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, porte_applicative_mapping_list);
  196.             }
  197.             if (ct_list == null) {
  198.                 ct_list = new ArrayList<>();
  199.                 whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ct_list);
  200.             }
  201.             if (allarme_list == null) {
  202.                 allarme_list = new ArrayList<>();
  203.                 whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarme_list);
  204.             }
  205.             if (trasformazionePD_mapping_list == null) {
  206.                 trasformazionePD_mapping_list = new ArrayList<>();
  207.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PD, trasformazionePD_mapping_list);
  208.             }
  209.             if (trasformazionePD_list == null) {
  210.                 trasformazionePD_list = new ArrayList<>();
  211.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PD, trasformazionePD_list);
  212.             }
  213.             if (trasformazionePA_mapping_list == null) {
  214.                 trasformazionePA_mapping_list = new ArrayList<>();
  215.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA, trasformazionePA_mapping_list);
  216.             }
  217.             if (trasformazionePA_list == null) {
  218.                 trasformazionePA_list = new ArrayList<>();
  219.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PA, trasformazionePA_list);
  220.             }

  222.             // Porte delegate, autorizzazione
  223.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  224.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_SA);
  225.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  226.             sqlQueryObject.addSelectField("nome_porta");
  227.             sqlQueryObject.setANDLogicOperator(true);
  228.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_SA+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  229.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  230.             queryString = sqlQueryObject.createSQLQuery();
  231.             stmt = con.prepareStatement(queryString);
  232.             stmt.setLong(1, idServizioApplicativoLong);
  233.             risultato = stmt.executeQuery();
  234.             while (risultato.next()){
  235.                 String nome = risultato.getString("nome_porta");
  236.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  237.                 if(resultPorta.mapping) {
  238.                     autorizzazionePD_mapping_list.add(resultPorta.label);
  239.                 }
  240.                 else {
  241.                     autorizzazionePD_list.add(resultPorta.label);
  242.                 }
  243.                 isInUso = true;
  244.             }
  245.             risultato.close();
  246.             stmt.close();
  247.             
  248.             
  249.             // Porte delegate, autorizzazione (token)
  250.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  251.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TOKEN_SA);
  252.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  253.             sqlQueryObject.addSelectField("nome_porta");
  254.             sqlQueryObject.setANDLogicOperator(true);
  255.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TOKEN_SA+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  256.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  257.             queryString = sqlQueryObject.createSQLQuery();
  258.             stmt = con.prepareStatement(queryString);
  259.             stmt.setLong(1, idServizioApplicativoLong);
  260.             risultato = stmt.executeQuery();
  261.             while (risultato.next()){
  262.                 String nome = risultato.getString("nome_porta");
  263.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  264.                 if(resultPorta.mapping) {
  265.                     autorizzazioneTokenPD_mapping_list.add(resultPorta.label);
  266.                 }
  267.                 else {
  268.                     autorizzazioneTokenPD_list.add(resultPorta.label);
  269.                 }
  270.                 isInUso = true;
  271.             }
  272.             risultato.close();
  273.             stmt.close();
  274.             
  275.             
  276.             // Porte applicative, autorizzazione
  277.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  278.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA_AUTORIZZATI);
  279.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  280.             sqlQueryObject.addSelectField("nome_porta");
  281.             sqlQueryObject.setANDLogicOperator(true);
  282.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA_AUTORIZZATI+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  283.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  284.             queryString = sqlQueryObject.createSQLQuery();
  285.             stmt = con.prepareStatement(queryString);
  286.             stmt.setLong(1, idServizioApplicativoLong);
  287.             risultato = stmt.executeQuery();
  288.             while (risultato.next()){
  289.                 String nome = risultato.getString("nome_porta");
  290.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  291.                 if(resultPorta.mapping) {
  292.                     if(resultPorta.erogazioneModi)
  293.                         autorizzazionePA_mapping_modi_list.add(resultPorta.label);
  294.                     else
  295.                         autorizzazionePA_mapping_list.add(resultPorta.label);
  296.                 }
  297.                 else {
  298.                     if(resultPorta.erogazioneModi)
  299.                         autorizzazionePA_modi_list.add(resultPorta.label);
  300.                     else
  301.                         autorizzazionePA_list.add(resultPorta.label);
  302.                 }
  303.                 isInUso = true;
  304.             }
  305.             risultato.close();
  306.             stmt.close();
  307.             
  308.             
  309.             // Porte applicative, autorizzazione (token)
  310.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  311.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TOKEN_SA);
  312.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  313.             sqlQueryObject.addSelectField("nome_porta");
  314.             sqlQueryObject.setANDLogicOperator(true);
  315.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TOKEN_SA+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  316.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  317.             queryString = sqlQueryObject.createSQLQuery();
  318.             stmt = con.prepareStatement(queryString);
  319.             stmt.setLong(1, idServizioApplicativoLong);
  320.             risultato = stmt.executeQuery();
  321.             while (risultato.next()){
  322.                 String nome = risultato.getString("nome_porta");
  323.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  324.                 if(resultPorta.mapping) {
  325.                     autorizzazioneTokenPA_mapping_list.add(resultPorta.label);
  326.                 }
  327.                 else {
  328.                     autorizzazioneTokenPA_list.add(resultPorta.label);
  329.                 }
  330.                 isInUso = true;
  331.             }
  332.             risultato.close();
  333.             stmt.close(); 

  335.             
  336.             
  337.             if(verificaRuoli) {
  338.                 
  339.                 // Raccolgo prima i ruoli
  340.                 List<String> listRuoliSA = new ArrayList<>();
  341.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  342.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  343.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  344.                 sqlQueryObject.addSelectField("ruolo");
  345.                 sqlQueryObject.setANDLogicOperator(true);
  346.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id=?");
  347.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_RUOLI+".id_servizio_applicativo="+CostantiDB.SERVIZI_APPLICATIVI+".id");
  348.                 queryString = sqlQueryObject.createSQLQuery();
  349.                 stmt = con.prepareStatement(queryString);
  350.                 stmt.setLong(1, idServizioApplicativoLong);
  351.                 risultato = stmt.executeQuery();
  352.                 while (risultato.next()){
  353.                     String ruolo = risultato.getString("ruolo");
  354.                     listRuoliSA.add(ruolo);
  355.                 }
  356.                 risultato.close();
  357.                 stmt.close();
  358.                 
  359.                 if(!listRuoliSA.isEmpty()) {
  360.                 
  361.                     _checkServizioApplicativo_ruoloInUsoInPorteDelegate(con, tipoDB, normalizeObjectIds,
  362.                             CostantiDB.PORTE_DELEGATE_RUOLI,
  363.                             listRuoliSA,
  364.                             ruoliPD_mapping_list, ruoliPD_list);
  365.                     
  366.                     _checkServizioApplicativo_ruoloInUsoInPorteDelegate(con, tipoDB, normalizeObjectIds,
  367.                             CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI,
  368.                             listRuoliSA,
  369.                             ruoliTokenPD_mapping_list, ruoliTokenPD_list);
  370.                                     
  371.                     boolean isInUsoRuoli = _checkServizioApplicativo_ruoloInUsoInPorteApplicative(con, tipoDB, normalizeObjectIds,
  372.                             CostantiDB.PORTE_APPLICATIVE_RUOLI,
  373.                             listRuoliSA,
  374.                             ruoliPA_mapping_list, ruoliPA_list,
  375.                             ruoliPA_mapping_list, ruoliPA_list);
  376.                     if(isInUsoRuoli) {
  377.                         isInUso = true;
  378.                     }
  379.                     
  380.                     boolean isInUsoRuoliToken = _checkServizioApplicativo_ruoloInUsoInPorteApplicative(con, tipoDB, normalizeObjectIds,
  381.                             CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI,
  382.                             listRuoliSA,
  383.                             ruoliTokenPA_mapping_list, ruoliTokenPA_list,
  384.                             ruoliTokenPA_mapping_modi_list, ruoliTokenPA_modi_list);
  385.                     if(isInUsoRuoliToken) {
  386.                         isInUso = true;
  387.                     }
  388.                 }
  389.             }
  390.             


  393.             // Porte applicative
  394.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  395.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  396.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  397.             sqlQueryObject.addSelectField("*");
  398.             sqlQueryObject.setANDLogicOperator(true);
  399.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  400.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  401.             queryString = sqlQueryObject.createSQLQuery();
  402.             stmt = con.prepareStatement(queryString);
  403.             stmt.setLong(1, idServizioApplicativoLong);
  404.             risultato = stmt.executeQuery();
  405.             while (risultato.next()){
  406.                 String nome = risultato.getString("nome_porta");
  407.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  408.                 if(resultPorta.mapping) {
  409.                     porte_applicative_mapping_list.add(resultPorta.label);
  410.                 }
  411.                 else {
  412.                     porte_applicative_list.add(resultPorta.label);
  413.                 }
  414.                 isInUso = true;
  415.             }
  416.             risultato.close();
  417.             stmt.close();

  419.             
  420.             // Controllo che il servizio aplicativo non sia associato a policy di controllo del traffico o allarmi
  421.             
  422.             int max = 2;
  423.             if(!CostantiDB.isAllarmiEnabled()) {
  424.                 max=1;
  425.             }
  426.             for (int i = 0; i < max; i++) {
  427.                 
  428.                 String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  429.                 String identificativo_column = "active_policy_id";
  430.                 String alias_column = "policy_alias";
  431.                 List<String> list = ct_list;
  432.                 String oggetto = "Policy";
  433.                 boolean allarmi = false;
  434.                 if(i==1) {
  435.                     tabella = CostantiDB.ALLARMI;
  436.                     identificativo_column = "nome";
  437.                     alias_column = "alias";
  438.                     list = allarme_list;
  439.                     oggetto = "Allarme";
  440.                     allarmi=true;
  441.                 }
  442.                 
  443.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  444.                 sqlQueryObject.addFromTable(tabella);
  445.                 sqlQueryObject.addSelectField(identificativo_column);
  446.                 sqlQueryObject.addSelectField(alias_column);
  447.                 sqlQueryObject.addSelectField("filtro_ruolo");
  448.                 sqlQueryObject.addSelectField("filtro_porta");
  449.                 sqlQueryObject.setANDLogicOperator(false); // OR
  450.                 sqlQueryObject.addWhereCondition(true, 
  451.                         tabella+".filtro_tipo_fruitore = ?", 
  452.                         tabella+".filtro_nome_fruitore = ?",
  453.                         tabella+".filtro_sa_fruitore = ?");
  454.                 if(!allarmi) {
  455.                     sqlQueryObject.addWhereCondition(true, 
  456.                             tabella+".filtro_tipo_erogatore = ?", 
  457.                             tabella+".filtro_nome_erogatore = ?",
  458.                             tabella+".filtro_sa_erogatore = ?");
  459.                 }
  460.                 sqlQueryObject.addOrderBy("filtro_ruolo");
  461.                 sqlQueryObject.addOrderBy("filtro_porta");
  462.                 queryString = sqlQueryObject.createSQLQuery();
  463.                 stmt = con.prepareStatement(queryString);
  464.                 int index = 1;
  465.                 stmt.setString(index++, idServizioApplicativo.getIdSoggettoProprietario().getTipo());
  466.                 stmt.setString(index++, idServizioApplicativo.getIdSoggettoProprietario().getNome());
  467.                 stmt.setString(index++, idServizioApplicativo.getNome());
  468.                 if(!allarmi) {
  469.                     stmt.setString(index++, idServizioApplicativo.getIdSoggettoProprietario().getTipo());
  470.                     stmt.setString(index++, idServizioApplicativo.getIdSoggettoProprietario().getNome());
  471.                     stmt.setString(index++, idServizioApplicativo.getNome());
  472.                 }
  473.                 risultato = stmt.executeQuery();
  474.                 while (risultato.next()) {
  475.                     
  476.                     String alias = risultato.getString(alias_column);
  477.                     if(alias== null || "".equals(alias)) {
  478.                         alias = risultato.getString(identificativo_column);
  479.                     }
  480.                     
  481.                     String nomePorta = risultato.getString("filtro_porta");
  482.                     String filtro_ruolo = risultato.getString("filtro_ruolo");
  483.                     if(nomePorta!=null) {
  484.                         String tipo = null;
  485.                         String label = null;
  486.                         if("delegata".equals(filtro_ruolo)) {
  487.                             try {
  488.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  489.                                 if(resultPorta.mapping) {
  490.                                     label = "Fruizione di Servizio "+ resultPorta.label;
  491.                                 }
  492.                             }catch(Exception e) {
  493.                                 tipo = "Outbound";
  494.                             }
  495.                         }
  496.                         else if("applicativa".equals(filtro_ruolo)) {
  497.                             try {
  498.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  499.                                 if(resultPorta.mapping) {
  500.                                     label = "Erogazione di Servizio "+ resultPorta.label;
  501.                                 }
  502.                             }catch(Exception e) {
  503.                                 tipo = "Inbound";
  504.                             }
  505.                         }
  506.                         else {
  507.                             tipo = filtro_ruolo;
  508.                         }
  509.                         if(label==null) {
  510.                             list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  511.                         }
  512.                         else {
  513.                             list.add(oggetto+" '"+alias+"' attiva nella "+label);
  514.                         }
  515.                     }
  516.                     else {
  517.                         list.add(oggetto+" '"+alias+"'");
  518.                     }
  519.     
  520.                     isInUso = true;
  521.                 }
  522.                 risultato.close();
  523.                 stmt.close();
  524.             }
  525.             
  526.             
  527.             
  528.             // Porte delegate, trasformazioni
  529.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  530.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA);
  531.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI);
  532.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  533.             sqlQueryObject.addSelectField("nome_porta");
  534.             sqlQueryObject.setANDLogicOperator(true);
  535.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  536.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI_SA+".id_trasformazione="+CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id");
  537.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  538.             queryString = sqlQueryObject.createSQLQuery();
  539.             stmt = con.prepareStatement(queryString);
  540.             stmt.setLong(1, idServizioApplicativoLong);
  541.             risultato = stmt.executeQuery();
  542.             while (risultato.next()){
  543.                 String nome = risultato.getString("nome_porta");
  544.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  545.                 if(resultPorta.mapping) {
  546.                     trasformazionePD_mapping_list.add(resultPorta.label);
  547.                 }
  548.                 else {
  549.                     trasformazionePD_list.add(resultPorta.label);
  550.                 }
  551.                 isInUso = true;
  552.             }
  553.             risultato.close();
  554.             stmt.close();
  555.             
  556.             
  557.             
  558.             // Porte applicative, trasformazioni
  559.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  560.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA);
  561.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI);
  562.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  563.             sqlQueryObject.addSelectField("nome_porta");
  564.             sqlQueryObject.setANDLogicOperator(true);
  565.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  566.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SA+".id_trasformazione="+CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id");
  567.             sqlQueryObject.addWhereCondition("id_servizio_applicativo=?");
  568.             queryString = sqlQueryObject.createSQLQuery();
  569.             stmt = con.prepareStatement(queryString);
  570.             stmt.setLong(1, idServizioApplicativoLong);
  571.             risultato = stmt.executeQuery();
  572.             while (risultato.next()){
  573.                 String nome = risultato.getString("nome_porta");
  574.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  575.                 if(resultPorta.mapping) {
  576.                     trasformazionePA_mapping_list.add(resultPorta.label);
  577.                 }
  578.                 else {
  579.                     trasformazionePA_list.add(resultPorta.label);
  580.                 }
  581.                 isInUso = true;
  582.             }
  583.             risultato.close();
  584.             stmt.close();
  585.             
  586.             
  587.             
  588.             return isInUso;

  590.         } catch (Exception se) {
  591.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  592.         } finally {
  593.             // Chiudo statement and resultset
  594.             JDBCUtilities.closeResources(risultato2, stmt2);
  595.             JDBCUtilities.closeResources(risultato, stmt);
  596.         }
  597.     }
  598.     
  599.     private static boolean _checkServizioApplicativo_ruoloInUsoInPorteDelegate(Connection con, String tipoDB, boolean normalizeObjectIds,
  600.             String nomeTabella,
  601.             List<String> listRuoliSA,
  602.             List<String> ruoliPD_mapping_list, List<String> ruoliPD_list) throws Exception {
  603.         boolean isInUso = false;
  604.         PreparedStatement stmt = null;
  605.         ResultSet risultato = null;
  606.         try {
  607.             
  608.             List<String> distinctPorteDelegate = new ArrayList<>();
  609.             List<String> verificaPorteDelegateAll = new ArrayList<>();
  610.             
  611.             for (String ruolo : listRuoliSA) {
  612.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  613.                 sqlQueryObject.addFromTable(nomeTabella);
  614.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  615.                 sqlQueryObject.addSelectField("nome_porta");
  616.                 sqlQueryObject.addSelectField("ruoli_match");
  617.                 sqlQueryObject.setANDLogicOperator(true);
  618.                 sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  619.                 sqlQueryObject.addWhereCondition(nomeTabella+".ruolo=?");
  620.                 String queryString = sqlQueryObject.createSQLQuery();
  621.                 stmt = con.prepareStatement(queryString);
  622.                 stmt.setString(1, ruolo);
  623.                 risultato = stmt.executeQuery();
  624.                 while (risultato.next()){
  625.                     String nome = risultato.getString("nome_porta");
  626.                     String ruolo_match = risultato.getString("ruoli_match");
  627.                     if(RuoloTipoMatch.ANY.getValue().equals(ruolo_match)) {
  628.                         if(distinctPorteDelegate.contains(nome)) {
  629.                             continue;
  630.                         }
  631.                         else {
  632.                             distinctPorteDelegate.add(nome);
  633.                         }
  634.                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  635.                         if(resultPorta.mapping) {
  636.                             ruoliPD_mapping_list.add(resultPorta.label);
  637.                         }
  638.                         else {
  639.                             ruoliPD_list.add(resultPorta.label);
  640.                         }
  641.                         isInUso = true;
  642.                     }
  643.                     else {
  644.                         // devo verificare tutti i ruoli richiesti
  645.                         if(verificaPorteDelegateAll.contains(nome)) {
  646.                             continue;
  647.                         }
  648.                         else {
  649.                             verificaPorteDelegateAll.add(nome);
  650.                         }
  651.                     }
  652.                 }
  653.                 risultato.close();
  654.                 stmt.close();   
  655.             }
  656.             
  657.             // autorizzazione 'all'
  658.             if(!verificaPorteDelegateAll.isEmpty()) {
  659.                 for (String nome : verificaPorteDelegateAll) {
  660.                     
  661.                     // Raccolgo prima i ruoli della porta
  662.                     List<String> listRuoliPorta = new ArrayList<>();
  663.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  664.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  665.                     sqlQueryObject.addFromTable(nomeTabella);
  666.                     sqlQueryObject.addSelectField("ruolo");
  667.                     sqlQueryObject.setANDLogicOperator(true);
  668.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta=?");
  669.                     sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  670.                     String queryString = sqlQueryObject.createSQLQuery();
  671.                     stmt = con.prepareStatement(queryString);
  672.                     stmt.setString(1, nome);
  673.                     risultato = stmt.executeQuery();
  674.                     while (risultato.next()){
  675.                         String ruolo = risultato.getString("ruolo");
  676.                         listRuoliPorta.add(ruolo);
  677.                     }
  678.                     risultato.close();
  679.                     stmt.close();
  680.                     
  681.                     if(!listRuoliPorta.isEmpty()) {
  682.                         boolean match = true;
  683.                         for (String ruoloPorta : listRuoliPorta) {
  684.                             if(!listRuoliSA.contains(ruoloPorta)) {
  685.                                 match = false;
  686.                                 break;
  687.                             }
  688.                         }
  689.                         if(match) {
  690.                             if(distinctPorteDelegate.contains(nome)) {
  691.                                 continue;
  692.                             }
  693.                             else {
  694.                                 distinctPorteDelegate.add(nome);
  695.                             }
  696.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  697.                             if(resultPorta.mapping) {
  698.                                 ruoliPD_mapping_list.add(resultPorta.label);
  699.                             }
  700.                             else {
  701.                                 ruoliPD_list.add(resultPorta.label);
  702.                             }
  703.                             isInUso = true;
  704.                         }
  705.                     }
  706.                     
  707.                 }
  708.             }
  709.             
  710.         } finally {
  711.             // Chiudo statement and resultset
  712.             try {
  713.                 if (risultato != null) {
  714.                     risultato.close();
  715.                 }
  716.             } catch (Exception e) {
  717.                 // ignore
  718.             }
  719.             try {
  720.                 if (stmt != null) {
  721.                     stmt.close();
  722.                 }
  723.             } catch (Exception e) {
  724.                 // ignore
  725.             }
  726.         }
  727.         return isInUso;
  728.     }
  729.     
  730.     private static boolean _checkServizioApplicativo_ruoloInUsoInPorteApplicative(Connection con, String tipoDB, boolean normalizeObjectIds,
  731.             String nomeTabella,
  732.             List<String> listRuoliSA,
  733.             List<String> ruoliPA_mapping_list, List<String> ruoliPA_list,
  734.             List<String> ruoliPA_mapping_modi_list, List<String> ruoliPA_modi_list) throws Exception {
  735.         boolean isInUso = false;
  736.         PreparedStatement stmt = null;
  737.         ResultSet risultato = null;
  738.         try {
  739.             
  740.             List<String> distinctPorteApplicative = new ArrayList<>();
  741.             List<String> verificaPorteApplicativeAll = new ArrayList<>();
  742.             
  743.             for (String ruolo : listRuoliSA) {
  744.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  745.                 sqlQueryObject.addFromTable(nomeTabella);
  746.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  747.                 sqlQueryObject.addSelectField("nome_porta");
  748.                 sqlQueryObject.addSelectField("ruoli_match");
  749.                 sqlQueryObject.setANDLogicOperator(true);
  750.                 sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  751.                 sqlQueryObject.addWhereCondition(nomeTabella+".ruolo=?");
  752.                 String queryString = sqlQueryObject.createSQLQuery();
  753.                 stmt = con.prepareStatement(queryString);
  754.                 stmt.setString(1, ruolo);
  755.                 risultato = stmt.executeQuery();
  756.                 while (risultato.next()){
  757.                     String nome = risultato.getString("nome_porta");
  758.                     String ruolo_match = risultato.getString("ruoli_match");
  759.                     if(RuoloTipoMatch.ANY.getValue().equals(ruolo_match)) {
  760.                         if(distinctPorteApplicative.contains(nome)) {
  761.                             continue;
  762.                         }
  763.                         else {
  764.                             distinctPorteApplicative.add(nome);
  765.                         }
  766.                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  767.                         if(resultPorta.mapping) {
  768.                             if(resultPorta.erogazioneModi)
  769.                                 ruoliPA_mapping_modi_list.add(resultPorta.label);
  770.                             else
  771.                                 ruoliPA_mapping_list.add(resultPorta.label);
  772.                         }
  773.                         else {
  774.                             if(resultPorta.erogazioneModi)
  775.                                 ruoliPA_modi_list.add(resultPorta.label);
  776.                             else
  777.                                 ruoliPA_list.add(resultPorta.label);
  778.                         }
  779.                         isInUso = true;
  780.                     }
  781.                     else {
  782.                         // devo verificare tutti i ruoli richiesti
  783.                         if(verificaPorteApplicativeAll.contains(nome)) {
  784.                             continue;
  785.                         }
  786.                         else {
  787.                             verificaPorteApplicativeAll.add(nome);
  788.                         }
  789.                     }
  790.                 }
  791.                 risultato.close();
  792.                 stmt.close();   
  793.             }
  794.             
  795.             // autorizzazione 'all'
  796.             if(!verificaPorteApplicativeAll.isEmpty()) {
  797.                 for (String nome : verificaPorteApplicativeAll) {
  798.                     
  799.                     // Raccolgo prima i ruoli della porta
  800.                     List<String> listRuoliPorta = new ArrayList<>();
  801.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  802.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  803.                     sqlQueryObject.addFromTable(nomeTabella);
  804.                     sqlQueryObject.addSelectField("ruolo");
  805.                     sqlQueryObject.setANDLogicOperator(true);
  806.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta=?");
  807.                     sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  808.                     String queryString = sqlQueryObject.createSQLQuery();
  809.                     stmt = con.prepareStatement(queryString);
  810.                     stmt.setString(1, nome);
  811.                     risultato = stmt.executeQuery();
  812.                     while (risultato.next()){
  813.                         String ruolo = risultato.getString("ruolo");
  814.                         listRuoliPorta.add(ruolo);
  815.                     }
  816.                     risultato.close();
  817.                     stmt.close();
  818.                     
  819.                     if(!listRuoliPorta.isEmpty()) {
  820.                         boolean match = true;
  821.                         for (String ruoloPorta : listRuoliPorta) {
  822.                             if(!listRuoliSA.contains(ruoloPorta)) {
  823.                                 match = false;
  824.                                 break;
  825.                             }
  826.                         }
  827.                         if(match) {
  828.                             if(distinctPorteApplicative.contains(nome)) {
  829.                                 continue;
  830.                             }
  831.                             else {
  832.                                 distinctPorteApplicative.add(nome);
  833.                             }
  834.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  835.                             if(resultPorta.mapping) {
  836.                                 if(resultPorta.erogazioneModi)
  837.                                     ruoliPA_mapping_modi_list.add(resultPorta.label);
  838.                                 else
  839.                                     ruoliPA_mapping_list.add(resultPorta.label);
  840.                             }
  841.                             else {
  842.                                 if(resultPorta.erogazioneModi)
  843.                                     ruoliPA_modi_list.add(resultPorta.label);
  844.                                 else
  845.                                     ruoliPA_list.add(resultPorta.label);
  846.                             }
  847.                             isInUso = true;
  848.                         }
  849.                     }
  850.                     
  851.                 }
  852.             }
  853.         } finally {
  854.             // Chiudo statement and resultset
  855.             try {
  856.                 if (risultato != null) {
  857.                     risultato.close();
  858.                 }
  859.             } catch (Exception e) {
  860.                 // ignore
  861.             }
  862.             try {
  863.                 if (stmt != null) {
  864.                     stmt.close();
  865.                 }
  866.             } catch (Exception e) {
  867.                 // ignore
  868.             }
  869.         }
  870.         return isInUso;
  871.     }

  873.     protected static String toString(IDServizioApplicativo idServizioApplicativo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, boolean normalizeObjectIds){
  874.         
  875.         StringBuilder bf = new StringBuilder();
  876.         if(normalizeObjectIds) {
  877.             try {
  878.                 String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idServizioApplicativo.getIdSoggettoProprietario().getTipo());
  879.                 String labelSA = DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+idServizioApplicativo.getNome()+DBOggettiInUsoUtils.getSubjectSuffix(protocollo, idServizioApplicativo.getIdSoggettoProprietario());
  880.                 bf.append(labelSA);
  881.             }catch(Exception e) {
  882.                 bf.append(idServizioApplicativo.getIdSoggettoProprietario().toString()+"_"+idServizioApplicativo.getNome());
  883.             }
  884.         }
  885.         else {
  886.             bf.append(idServizioApplicativo.getIdSoggettoProprietario().toString()+"_"+idServizioApplicativo.getNome());
  887.         }
  888.         
  889.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  890.         String msg = "Applicativo '" +bf.toString() +"' non eliminabile perch&egrave; :"+separator;
  891.         if(prefix==false){
  892.             msg = "";
  893.         }
  894.         String separatorCategorie = "";
  895.         if(whereIsInUso.size()>1) {
  896.             separatorCategorie = separator;
  897.         }
  898.         for (ErrorsHandlerCostant key : keys) {
  899.             List<String> messages = whereIsInUso.get(key);

  901.             if ( messages!=null && messages.size() > 0) {
  902.                 msg += separatorCategorie;
  903.             }
  904.             
  905.             switch (key) {
  906.             case AUTORIZZAZIONE_MAPPING:
  907.                 if ( messages!=null && messages.size() > 0) {
  908.                     msg += "utilizzato nel Controllo degli Accessi (Autorizzazione Trasporto - Richiedenti Autorizzati) delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  909.                 }
  910.                 break;
  911.             case AUTORIZZAZIONE:
  912.                 if ( messages!=null && messages.size() > 0) {
  913.                     msg += "utilizzato nelle Porte Outbound (Controllo degli Accessi - Autorizzazione Trasporto -  Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  914.                 }
  915.                 break;
  916.             case AUTORIZZAZIONE_MAPPING_PA:
  917.                 if ( messages!=null && messages.size() > 0) {
  918.                     msg += "utilizzato nel Controllo degli Accessi (Autorizzazione Trasporto - Richiedenti Autorizzati) delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  919.                 }
  920.                 break;
  921.             case AUTORIZZAZIONE_PA:
  922.                 if ( messages!=null && messages.size() > 0) {
  923.                     msg += "utilizzato nelle Porte Inbound (Controllo degli Accessi - Autorizzazione Trasporto - Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  924.                 }
  925.                 break;
  926.             case AUTORIZZAZIONE_MAPPING_PA_MODI:
  927.                 if ( messages!=null && messages.size() > 0) {
  928.                     msg += "utilizzato nel Controllo degli Accessi (Autorizzazione Messaggio - Richiedenti Autorizzati) delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  929.                 }
  930.                 break;
  931.             case AUTORIZZAZIONE_PA_MODI:
  932.                 if ( messages!=null && messages.size() > 0) {
  933.                     msg += "utilizzato nelle Porte Inbound (Controllo degli Accessi - Autorizzazione Messaggio - Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  934.                 }
  935.                 break;
  936.                 
  937.             case AUTORIZZAZIONE_TOKEN_MAPPING_PD:
  938.                 if ( messages!=null && messages.size() > 0) {
  939.                     msg += "utilizzato nel Controllo degli Accessi (Autorizzazione Token - Richiedenti Autorizzati) delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  940.                 }
  941.                 break;
  942.             case AUTORIZZAZIONE_TOKEN_PD:
  943.                 if ( messages!=null && messages.size() > 0) {
  944.                     msg += "utilizzato nelle Porte Outbound (Controllo degli Accessi - Autorizzazione Token - Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  945.                 }
  946.                 break;
  947.             case AUTORIZZAZIONE_TOKEN_MAPPING_PA:
  948.                 if ( messages!=null && messages.size() > 0) {
  949.                     msg += "utilizzato nel Controllo degli Accessi (Autorizzazione Token - Richiedenti Autorizzati) delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  950.                 }
  951.                 break;
  952.             case AUTORIZZAZIONE_TOKEN_PA:
  953.                 if ( messages!=null && messages.size() > 0) {
  954.                     msg += "utilizzato nelle Porte Inbound (Controllo degli Accessi - Autorizzazione Token - Richiedenti Autorizzati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  955.                 }
  956.                 break;
  957.                 
  958.             case RUOLI_MAPPING:
  959.                 if ( messages!=null && messages.size() > 0) {
  960.                     msg += "compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  961.                 }
  962.                 break;
  963.             case RUOLI:
  964.                 if ( messages!=null && messages.size() > 0) {
  965.                     msg += "compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Porte Outbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  966.                 }
  967.                 break;
  968.             case RUOLI_MAPPING_PA:
  969.                 if ( messages!=null && messages.size() > 0) {
  970.                     msg += "compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  971.                 }
  972.                 break;
  973.             case RUOLI_PA:
  974.                 if ( messages!=null && messages.size() > 0) {
  975.                     msg += "compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  976.                 }
  977.                 break;
  978.                 
  979.             case RUOLI_TOKEN_MAPPING_PD:
  980.                 if ( messages!=null && messages.size() > 0) {
  981.                     msg += "compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  982.                 }
  983.                 break;
  984.             case RUOLI_TOKEN_PD:
  985.                 if ( messages!=null && messages.size() > 0) {
  986.                     msg += "compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Porte Outbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  987.                 }
  988.                 break;
  989.             case RUOLI_TOKEN_MAPPING_PA:
  990.                 if ( messages!=null && messages.size() > 0) {
  991.                     msg += "compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  992.                 }
  993.                 break;
  994.             case RUOLI_TOKEN_PA:
  995.                 if ( messages!=null && messages.size() > 0) {
  996.                     msg += "compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  997.                 }
  998.                 break;
  999.             case RUOLI_TOKEN_MAPPING_PA_MODI:
  1000.                 if ( messages!=null && messages.size() > 0) {
  1001.                     msg += "compatibile con l'Autorizzazione Messaggio per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1002.                 }
  1003.                 break;
  1004.             case RUOLI_TOKEN_PA_MODI:
  1005.                 if ( messages!=null && messages.size() > 0) {
  1006.                     msg += "compatibile con l'Autorizzazione Messaggio per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1007.                 }
  1008.                 break;
  1009.                 
  1010.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  1011.                 if ( messages!=null && messages.size() > 0 ) {
  1012.                     msg += "utilizzato come applicativo server nei connettori delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1013.                 }
  1014.                 break;
  1015.             case IN_USO_IN_PORTE_APPLICATIVE:
  1016.                 if ( messages!=null && messages.size() > 0 ) {
  1017.                     msg += "in uso in Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1018.                 }
  1019.                 break;
  1020.             case CONTROLLO_TRAFFICO:
  1021.                 if ( messages!=null && messages.size() > 0 ) {
  1022.                     msg += "utilizzato in policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1023.                 }
  1024.                 break;
  1025.             case ALLARMI:
  1026.                 if ( messages!=null && messages.size() > 0 ) {
  1027.                     msg += "utilizzato in Allarmi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1028.                 }
  1029.                 break;
  1030.             case TRASFORMAZIONE_MAPPING_PD:
  1031.                 if ( messages!=null && messages.size() > 0) {
  1032.                     msg += "utilizzato nel criterio di applicabilità della Trasformazione (Applicativi) per le Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1033.                 }
  1034.                 break;
  1035.             case TRASFORMAZIONE_PD:
  1036.                 if ( messages!=null && messages.size() > 0) {
  1037.                     msg += "utilizzato nelle Porte Outbound (Criterio di applicabilità della Trasformazione - Applicativi): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1038.                 }
  1039.                 break;
  1040.             case TRASFORMAZIONE_MAPPING_PA:
  1041.                 if ( messages!=null && messages.size() > 0) {
  1042.                     msg += "utilizzato nel criterio di applicabilità della Trasformazione (Applicativi) per le Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1043.                 }
  1044.                 break;
  1045.             case TRASFORMAZIONE_PA:
  1046.                 if ( messages!=null && messages.size() > 0) {
  1047.                     msg += "utilizzato nelle Porte Inbound (Criterio di applicabilità della Trasformazione - Applicativi): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1048.                 }
  1049.                 break;
  1050.             default:
  1051.                 msg += "utilizzato in oggetto non codificato ("+key+")"+separator;
  1052.                 break;
  1053.             }

  1055.         }// chiudo for

  1057.         return msg;
  1058.     }
  1059.     
  1060. }
Created with JaCoCo 0.8.8.202204050719