DBOggettiInUsoUtils_plugins.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.text.MessageFormat;
  27. import java.util.ArrayList;
  28. import java.util.List;
  29. import java.util.Map;
  30. import java.util.Set;

  32. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  33. import org.openspcoop2.core.commons.DBUtils;
  34. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  35. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  36. import org.openspcoop2.core.constants.CostantiDB;
  37. import org.openspcoop2.core.controllo_traffico.constants.TipoFiltroApplicativo;
  38. import org.openspcoop2.utils.UtilsException;
  39. import org.openspcoop2.utils.jdbc.JDBCParameterUtilities;
  40. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  41. import org.openspcoop2.utils.sql.ISQLQueryObject;
  42. import org.openspcoop2.utils.sql.LikeConfig;
  43. import org.openspcoop2.utils.sql.SQLObjectFactory;

  45. /**
  46.  * DBOggettiInUsoUtils_plugins
  47.  * 
  48.  * @author Andrea Poli (apoli@link.it)
  49.  * @author $Author$
  50.  * @version $Rev$, $Date$
  51.  * 
  52.  */
  53. public class DBOggettiInUsoUtils_plugins {

  55.     protected static boolean isPluginInUso(Connection con, String tipoDB, String className, String label, String tipoPlugin, String tipo, 
  56.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {

  58.         String nomeMetodo = "isPluginInUso";

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

  68.             long idPluginLong = DBUtils.getIdPlugin(className, label, tipoPlugin, tipo, con, tipoDB);
  69.             if(idPluginLong<=0){
  70.                 throw new UtilsException("Plugin con Label ["+label+"] non trovato");
  71.             }

  73.             if("CONNETTORE".equals(tipoPlugin)) {
  74.                 
  75.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  76.                 sqlQueryObject.addFromTable(CostantiDB.CONNETTORI);
  77.                 sqlQueryObject.addSelectField("id");
  78.                 sqlQueryObject.setANDLogicOperator(true);
  79.                 sqlQueryObject.addWhereCondition("endpointtype=?");
  80.                 sqlQueryObject.addWhereCondition("custom=?");
  81.                 queryString = sqlQueryObject.createSQLQuery();
  82.                 stmt = con.prepareStatement(queryString);
  83.                 stmt.setString(1, tipo);
  84.                 stmt.setInt(2, CostantiDB.TRUE);
  85.                 risultato = stmt.executeQuery();
  86.                 List<Long> idConnettori = new ArrayList<Long>();
  87.                 while (risultato.next()){
  88.                     long idConnettore = risultato.getLong("id");
  89.                     idConnettori.add(idConnettore);
  90.                 }
  91.                 risultato.close();
  92.                 stmt.close();
  93.                 
  94.                 if(idConnettori!=null && !idConnettori.isEmpty()) {
  95.                     
  96.                     isInUso = true; // già è in uso... anche se fallisse sotto il mapping
  97.                 
  98.                 }
  99.                 
  100.                 /*
  101.                  * Le seguenti liste vengono inizializzate dentro il metodo.
  102.                  * 
  103.                  * List<String> connettorePA_list = whereIsInUso.get(ErrorsHandlerCostant.CONNETTORE_PA);
  104.                  * List<String> connettorePD_list = whereIsInUso.get(ErrorsHandlerCostant.CONNETTORE_PD);
  105.                  * List<String> mapping_connettorePA_list = whereIsInUso.get(ErrorsHandlerCostant.CONNETTORE_MAPPING_PA);
  106.                  * List<String> mapping_connettorePD_list = whereIsInUso.get(ErrorsHandlerCostant.CONNETTORE_MAPPING_PD);
  107.                  **/
  108.                 DBOggettiInUsoUtils.formatConnettori(idConnettori,whereIsInUso, con, normalizeObjectIds, tipoDB);
  109.             }
  110.             
  111.             else if("AUTENTICAZIONE".equals(tipoPlugin) || 
  112.                     "AUTORIZZAZIONE".equals(tipoPlugin) || 
  113.                     "AUTORIZZAZIONE_CONTENUTI".equals(tipoPlugin) ||
  114.                     "INTEGRAZIONE".equals(tipoPlugin) ||
  115.                     "BEHAVIOUR".equals(tipoPlugin)) {
  116.                 
  117.                 boolean autenticazione = "AUTENTICAZIONE".equals(tipoPlugin);
  118.                 boolean autorizzazione = "AUTORIZZAZIONE".equals(tipoPlugin);
  119.                 boolean autorizzazione_contenuti = "AUTORIZZAZIONE_CONTENUTI".equals(tipoPlugin);
  120.                 boolean integrazione = "INTEGRAZIONE".equals(tipoPlugin);
  121.                 boolean behaviour = "BEHAVIOUR".equals(tipoPlugin);
  122.                 
  123.                 
  124.                 ErrorsHandlerCostant PD_tipoControllo_mapping = null;
  125.                 ErrorsHandlerCostant PD_tipoControllo = null;
  126.                 ErrorsHandlerCostant PA_tipoControllo_mapping = null;
  127.                 ErrorsHandlerCostant PA_tipoControllo = null;
  128.                 String colonna = "";
  129.                 if(autenticazione){
  130.                     PD_tipoControllo_mapping = ErrorsHandlerCostant.AUTENTICAZIONE_MAPPING_PD;
  131.                     PD_tipoControllo = ErrorsHandlerCostant.AUTENTICAZIONE_PD;
  132.                     PA_tipoControllo_mapping = ErrorsHandlerCostant.AUTENTICAZIONE_MAPPING_PA;
  133.                     PA_tipoControllo = ErrorsHandlerCostant.AUTENTICAZIONE_PA;
  134.                     colonna = "autenticazione";
  135.                 }
  136.                 else if(autorizzazione){
  137.                     PD_tipoControllo_mapping = ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PD;
  138.                     PD_tipoControllo = ErrorsHandlerCostant.AUTORIZZAZIONE_PD;
  139.                     PA_tipoControllo_mapping = ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING_PA;
  140.                     PA_tipoControllo = ErrorsHandlerCostant.AUTORIZZAZIONE_PA;
  141.                     colonna = "autorizzazione";
  142.                 }
  143.                 else if(autorizzazione_contenuti){
  144.                     PD_tipoControllo_mapping = ErrorsHandlerCostant.AUTORIZZAZIONE_CONTENUTI_MAPPING_PD;
  145.                     PD_tipoControllo = ErrorsHandlerCostant.AUTORIZZAZIONE_CONTENUTI_PD;
  146.                     PA_tipoControllo_mapping = ErrorsHandlerCostant.AUTORIZZAZIONE_CONTENUTI_MAPPING_PA;
  147.                     PA_tipoControllo = ErrorsHandlerCostant.AUTORIZZAZIONE_CONTENUTI_PA;
  148.                     colonna = "autorizzazione_contenuto";
  149.                 }
  150.                 else if(integrazione) {
  151.                     PD_tipoControllo_mapping = ErrorsHandlerCostant.INTEGRAZIONE_MAPPING_PD;
  152.                     PD_tipoControllo = ErrorsHandlerCostant.INTEGRAZIONE_PD;
  153.                     PA_tipoControllo_mapping = ErrorsHandlerCostant.INTEGRAZIONE_MAPPING_PA;
  154.                     PA_tipoControllo = ErrorsHandlerCostant.INTEGRAZIONE_PA;
  155.                     colonna = "integrazione";
  156.                 }
  157.                 else if(behaviour) {
  158.                     PA_tipoControllo_mapping = ErrorsHandlerCostant.BEHAVIOUR_MAPPING_PA;
  159.                     PA_tipoControllo = ErrorsHandlerCostant.BEHAVIOUR_PA;
  160.                     colonna = "behaviour";
  161.                 }
  162.                 
  163.                 List<String> PD_mapping_list = null;
  164.                 List<String> PD_list = null;
  165.                 if(!behaviour) {
  166.                     PD_mapping_list = whereIsInUso.get(PD_tipoControllo_mapping);
  167.                     PD_list = whereIsInUso.get(PD_tipoControllo);
  168.                 }
  169.                 List<String> PA_mapping_list = whereIsInUso.get(PA_tipoControllo_mapping);
  170.                 List<String> PA_list = whereIsInUso.get(PA_tipoControllo);
  171.                 
  172.                 if(!behaviour) {
  173.                     if (PD_mapping_list == null) {
  174.                         PD_mapping_list = new ArrayList<>();
  175.                         whereIsInUso.put(PD_tipoControllo_mapping, PD_mapping_list);
  176.                     }
  177.                     if (PD_list == null) {
  178.                         PD_list = new ArrayList<>();
  179.                         whereIsInUso.put(PD_tipoControllo, PD_list);
  180.                     }
  181.                 }
  182.                 if (PA_mapping_list == null) {
  183.                     PA_mapping_list = new ArrayList<>();
  184.                     whereIsInUso.put(PA_tipoControllo_mapping, PA_mapping_list);
  185.                 }
  186.                 if (PA_list == null) {
  187.                     PA_list = new ArrayList<>();
  188.                     whereIsInUso.put(PA_tipoControllo, PA_list);
  189.                 }
  190.                 
  191.                 int i = 0;
  192.                 if(behaviour) {
  193.                     i=1;
  194.                 }
  195.                 for (; i < 2; i++) {
  196.                     
  197.                     String table = CostantiDB.PORTE_DELEGATE;
  198.                     if(i==1) {
  199.                         table = CostantiDB.PORTE_APPLICATIVE;
  200.                     }
  201.                     
  202.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  203.                     sqlQueryObject.addFromTable(table);
  204.                     sqlQueryObject.addSelectField("nome_porta");
  205.                     sqlQueryObject.setANDLogicOperator(true);
  206.                     if(integrazione) {
  207.                         // condizione di controllo
  208.                         ISQLQueryObject sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  209.                         sqlQueryObjectOr.setANDLogicOperator(false);
  210.                         // (integrazione == 'NOME') OR (integrazione like 'NOME,%') OR (integrazione like '%,NOME') OR (integrazione like '%,applicabilita_azioni,%')
  211.                         // CLOB sqlQueryObjectOr.addWhereCondition(integrazione = ?");
  212.                         sqlQueryObjectOr.addWhereLikeCondition(colonna, tipo, false , false);
  213.                         sqlQueryObjectOr.addWhereLikeCondition(colonna, tipo+",", LikeConfig.startsWith(false));
  214.                         sqlQueryObjectOr.addWhereLikeCondition(colonna, ","+tipo, LikeConfig.endsWith(false));
  215.                         sqlQueryObjectOr.addWhereLikeCondition(colonna, ","+tipo+",", true , false);
  216.                         sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  217.                     }
  218.                     else {
  219.                         sqlQueryObject.addWhereCondition(colonna+"=?");
  220.                     }
  221.                     queryString = sqlQueryObject.createSQLQuery();
  222.                     stmt = con.prepareStatement(queryString);
  223.                     if(!integrazione) {
  224.                         stmt.setString(1, tipo);
  225.                     }
  226.                     risultato = stmt.executeQuery();
  227.                     while (risultato.next()){
  228.                         String nome = risultato.getString("nome_porta");
  229.                         if(CostantiDB.PORTE_DELEGATE.equals(table)) {
  230.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  231.                             if(resultPorta.mapping) {
  232.                                 PD_mapping_list.add(resultPorta.label);
  233.                             }
  234.                             else {
  235.                                 PD_list.add(resultPorta.label);
  236.                             }
  237.                         }
  238.                         else {
  239.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  240.                             if(resultPorta.mapping) {
  241.                                 PA_mapping_list.add(resultPorta.label);
  242.                             }
  243.                             else {
  244.                                 PA_list.add(resultPorta.label);
  245.                             }
  246.                         }
  247.                         isInUso = true;
  248.                     }
  249.                     risultato.close();
  250.                     stmt.close();
  251.                     
  252.                 }
  253.             }
  254.             
  255.             else if("RATE_LIMITING".equals(tipoPlugin)) {
  256.                 
  257.                 List<String> ct_list = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  258.                 if (ct_list == null) {
  259.                     ct_list = new ArrayList<>();
  260.                     whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ct_list);
  261.                 }   
  262.                 
  263.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  264.                 sqlQueryObject.addFromTable(CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY);
  265.                 sqlQueryObject.addSelectField("active_policy_id");
  266.                 sqlQueryObject.addSelectField("policy_alias");
  267.                 sqlQueryObject.addSelectField("filtro_ruolo");
  268.                 sqlQueryObject.addSelectField("filtro_porta");
  269.                 sqlQueryObject.setANDLogicOperator(false); // OR
  270.                 sqlQueryObject.addWhereCondition(true, 
  271.                         CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".filtro_key_enabled = ?",
  272.                         CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".filtro_key_type = ?",
  273.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".filtro_key_name", tipo, false, false));
  274.                 sqlQueryObject.addWhereCondition(true, 
  275.                         CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".group_key_enabled = ?",
  276.                         CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".group_key_type = ?",
  277.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".group_key_name", tipo, false, false));
  278.                 sqlQueryObject.addOrderBy("filtro_ruolo");
  279.                 sqlQueryObject.addOrderBy("filtro_porta");
  280.                 queryString = sqlQueryObject.createSQLQuery();
  281.                 stmt = con.prepareStatement(queryString);
  282.                 int index = 1;
  283.                 JDBCParameterUtilities utils = new JDBCParameterUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2());
  284.                 utils.setParameter(stmt, index++, true, boolean.class);
  285.                 stmt.setString(index++, TipoFiltroApplicativo.PLUGIN_BASED.getValue());
  286.                 utils.setParameter(stmt, index++, true, boolean.class);
  287.                 stmt.setString(index++, TipoFiltroApplicativo.PLUGIN_BASED.getValue());
  288.                 risultato = stmt.executeQuery();
  289.                 while (risultato.next()) {
  290.                     
  291.                     String alias = risultato.getString("policy_alias");
  292.                     if(alias== null || "".equals(alias)) {
  293.                         alias = risultato.getString("active_policy_id");
  294.                     }
  295.                     
  296.                     String nomePorta = risultato.getString("filtro_porta");
  297.                     String filtro_ruolo = risultato.getString("filtro_ruolo");
  298.                     if(nomePorta!=null) {
  299.                         String tipoPorta = null;
  300.                         String labelPorta = null;
  301.                         if("delegata".equals(filtro_ruolo)) {
  302.                             try {
  303.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  304.                                 if(resultPorta.mapping) {
  305.                                     labelPorta = "Fruizione di Servizio "+ resultPorta.label;
  306.                                 }
  307.                             }catch(Exception e) {
  308.                                 tipoPorta = "Outbound";
  309.                             }
  310.                         }
  311.                         else if("applicativa".equals(filtro_ruolo)) {
  312.                             try {
  313.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  314.                                 if(resultPorta.mapping) {
  315.                                     labelPorta = "Erogazione di Servizio "+ resultPorta.label;
  316.                                 }
  317.                             }catch(Exception e) {
  318.                                 tipoPorta = "Inbound";
  319.                             }
  320.                         }
  321.                         else {
  322.                             tipoPorta = filtro_ruolo;
  323.                         }
  324.                         if(labelPorta==null) {
  325.                             ct_list.add("Policy '"+alias+"' attiva nella porta '"+tipoPorta+"' '"+nomePorta+"' ");
  326.                         }
  327.                         else {
  328.                             ct_list.add("Policy '"+alias+"' attiva nella "+labelPorta);
  329.                         }
  330.                     }
  331.                     else {
  332.                         ct_list.add("Policy '"+alias+"'");
  333.                     }
  334.     
  335.                     isInUso = true;
  336.                 }
  337.                 risultato.close();
  338.                 stmt.close();
  339.             }
  340.                         
  341.             else if("ALLARME".equals(tipoPlugin)) {
  342.                 List<String> allarmiPD_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI_MAPPING_PD);
  343.                 List<String> allarmiPD_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI_PD);
  344.                 List<String> allarmiPA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI_MAPPING_PA);
  345.                 List<String> allarmiPA_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI_PA);
  346.                 List<String> allarmi_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI);
  347.                 
  348.                 if (allarmiPD_mapping_list == null) {
  349.                     allarmiPD_mapping_list = new ArrayList<>();
  350.                     whereIsInUso.put(ErrorsHandlerCostant.ALLARMI_MAPPING_PD, allarmiPD_mapping_list);
  351.                 }
  352.                 if (allarmiPD_list == null) {
  353.                     allarmiPD_list = new ArrayList<>();
  354.                     whereIsInUso.put(ErrorsHandlerCostant.ALLARMI_PD, allarmiPD_list);
  355.                 }
  356.                 if (allarmiPA_mapping_list == null) {
  357.                     allarmiPA_mapping_list = new ArrayList<>();
  358.                     whereIsInUso.put(ErrorsHandlerCostant.ALLARMI_MAPPING_PA, allarmiPA_mapping_list);
  359.                 }
  360.                 if (allarmiPA_list == null) {
  361.                     allarmiPA_list = new ArrayList<>();
  362.                     whereIsInUso.put(ErrorsHandlerCostant.ALLARMI_PA, allarmiPA_list);
  363.                 }
  364.                 if (allarmi_list == null) {
  365.                     allarmi_list = new ArrayList<>();
  366.                     whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarmi_list);
  367.                 }
  368.                 
  369.                 // allarmi
  370.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  371.                 sqlQueryObject.addFromTable(CostantiDB.ALLARMI);
  372.                 sqlQueryObject.addSelectField("nome");
  373.                 sqlQueryObject.setANDLogicOperator(true);
  374.                 sqlQueryObject.addWhereCondition("tipo=?");
  375.                 sqlQueryObject.addWhereIsNullCondition("filtro_porta");
  376.                 queryString = sqlQueryObject.createSQLQuery();
  377.                 stmt = con.prepareStatement(queryString);
  378.                 stmt.setString(1, tipo);
  379.                 risultato = stmt.executeQuery();
  380.                 while (risultato.next()){
  381.                     String nome = risultato.getString("nome");
  382.                     allarmi_list.add(nome);
  383.                     isInUso = true;
  384.                 }
  385.                 risultato.close();
  386.                 stmt.close();
  387.                 
  388.                 
  389.                 // Porte applicative, allarmi
  390.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  391.                 sqlQueryObject.addFromTable(CostantiDB.ALLARMI);
  392.                 sqlQueryObject.addSelectField("nome");
  393.                 sqlQueryObject.addSelectField("filtro_porta");
  394.                 sqlQueryObject.setANDLogicOperator(true);
  395.                 sqlQueryObject.addWhereCondition("tipo=?");
  396.                 sqlQueryObject.addWhereCondition("filtro_ruolo=?");
  397.                 sqlQueryObject.addWhereIsNotNullCondition("filtro_porta");
  398.                 queryString = sqlQueryObject.createSQLQuery();
  399.                 stmt = con.prepareStatement(queryString);
  400.                 stmt.setString(1, tipo);
  401.                 stmt.setString(2, RuoloPorta.APPLICATIVA.getValue());
  402.                 risultato = stmt.executeQuery();
  403.                 while (risultato.next()){
  404.                     String nome = risultato.getString("filtro_porta");
  405.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  406.                     if(resultPorta.mapping) {
  407.                         allarmiPA_mapping_list.add(resultPorta.label);
  408.                     }
  409.                     else {
  410.                         allarmiPA_list.add(resultPorta.label);
  411.                     }
  412.                     isInUso = true;
  413.                 }
  414.                 risultato.close();
  415.                 stmt.close();

  417.                 // Porte delegate, allarmi
  418.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  419.                 sqlQueryObject.addFromTable(CostantiDB.ALLARMI);
  420.                 sqlQueryObject.addSelectField("nome");
  421.                 sqlQueryObject.addSelectField("filtro_porta");
  422.                 sqlQueryObject.setANDLogicOperator(true);
  423.                 sqlQueryObject.addWhereCondition("tipo=?");
  424.                 sqlQueryObject.addWhereCondition("filtro_ruolo=?");
  425.                 sqlQueryObject.addWhereIsNotNullCondition("filtro_porta");
  426.                 queryString = sqlQueryObject.createSQLQuery();
  427.                 stmt = con.prepareStatement(queryString);
  428.                 stmt.setString(1, tipo);
  429.                 stmt.setString(2, RuoloPorta.DELEGATA.getValue());
  430.                 risultato = stmt.executeQuery();
  431.                 while (risultato.next()){
  432.                     String nome = risultato.getString("filtro_porta");
  433.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  434.                     if(resultPorta.mapping) {
  435.                         allarmiPD_mapping_list.add(resultPorta.label);
  436.                     }
  437.                     else {
  438.                         allarmiPD_list.add(resultPorta.label);
  439.                     }
  440.                     isInUso = true;
  441.                 }
  442.                 risultato.close();
  443.                 stmt.close();
  444.                 
  445.             }else if("MESSAGE_HANDLER".equals(tipoPlugin)) {
  446.                 List<String> messageHandlerPD_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.MESSAGE_HANDLER_MAPPING_PD);
  447.                 List<String> messageHandlerPD_list = whereIsInUso.get(ErrorsHandlerCostant.MESSAGE_HANDLER_PD);
  448.                 List<String> messageHandlerPA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.MESSAGE_HANDLER_MAPPING_PA);
  449.                 List<String> messageHandlerPA_list = whereIsInUso.get(ErrorsHandlerCostant.MESSAGE_HANDLER_PA);
  450.                 List<String> messageHandler_list = whereIsInUso.get(ErrorsHandlerCostant.MESSAGE_HANDLER);
  451.                 
  452.                 if (messageHandlerPD_mapping_list == null) {
  453.                     messageHandlerPD_mapping_list = new ArrayList<>();
  454.                     whereIsInUso.put(ErrorsHandlerCostant.MESSAGE_HANDLER_MAPPING_PD, messageHandlerPD_mapping_list);
  455.                 }
  456.                 if (messageHandlerPD_list == null) {
  457.                     messageHandlerPD_list = new ArrayList<>();
  458.                     whereIsInUso.put(ErrorsHandlerCostant.MESSAGE_HANDLER_PD, messageHandlerPD_list);
  459.                 }
  460.                 if (messageHandlerPA_mapping_list == null) {
  461.                     messageHandlerPA_mapping_list = new ArrayList<>();
  462.                     whereIsInUso.put(ErrorsHandlerCostant.MESSAGE_HANDLER_MAPPING_PA, messageHandlerPA_mapping_list);
  463.                 }
  464.                 if (messageHandlerPA_list == null) {
  465.                     messageHandlerPA_list = new ArrayList<>();
  466.                     whereIsInUso.put(ErrorsHandlerCostant.MESSAGE_HANDLER_PA, messageHandlerPA_list);
  467.                 }
  468.                 if (messageHandler_list == null) {
  469.                     messageHandler_list = new ArrayList<>();
  470.                     whereIsInUso.put(ErrorsHandlerCostant.MESSAGE_HANDLER, messageHandler_list);
  471.                 }
  472.                 
  473.                 // config handlers
  474.                 String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  475.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  476.                 sqlQueryObject.addFromTable(tabella);
  477.                 sqlQueryObject.addSelectField(tabella +".tipologia");
  478.                 sqlQueryObject.setANDLogicOperator(true);
  479.                 sqlQueryObject.addWhereCondition(tabella +".tipo=?");
  480.                 queryString = sqlQueryObject.createSQLQuery();
  481.                 stmt = con.prepareStatement(queryString);
  482.                 stmt.setString(1, tipo);
  483.                 risultato = stmt.executeQuery();
  484.                 while (risultato.next()){
  485.                     String tipologia = risultato.getString("tipologia");
  486.                     String labelMessaggio = formatMessageHandlerFromTipologia(tipologia);
  487.                     messageHandler_list.add(labelMessaggio);
  488.                     isInUso = true;
  489.                 }
  490.                 risultato.close();
  491.                 stmt.close();
  492.                 
  493.                 
  494.                 // Porte applicative, message handlers
  495.                 tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  496.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  497.                 sqlQueryObject.addFromTable(tabella);
  498.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  499.                 sqlQueryObject.addSelectField(tabella +".tipologia");
  500.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE +".nome_porta");
  501.                 sqlQueryObject.setANDLogicOperator(true);
  502.                 sqlQueryObject.addWhereCondition(tabella+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  503.                 sqlQueryObject.addWhereCondition(tabella+".tipo=?");
  504.                 queryString = sqlQueryObject.createSQLQuery();
  505.                 stmt = con.prepareStatement(queryString);
  506.                 stmt.setString(1, tipo);
  507.                 risultato = stmt.executeQuery();
  508.                 while (risultato.next()){
  509.                     String tipologia = risultato.getString("tipologia");
  510.                     String nome = risultato.getString("nome_porta");
  511.                     String labelMessaggio = formatMessageHandlerFromTipologia(tipologia);
  512.                     
  513.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  514.                     if(resultPorta.mapping) {
  515.                         messageHandlerPA_mapping_list.add(resultPorta.label + ": " + labelMessaggio);
  516.                     }
  517.                     else {
  518.                         messageHandlerPA_list.add(resultPorta.label + ": " + labelMessaggio);
  519.                     }
  520.                     isInUso = true;
  521.                 }
  522.                 risultato.close();
  523.                 stmt.close();

  525.                 // Porte delegate, message handlers
  526.                 tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  527.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  528.                 sqlQueryObject.addFromTable(tabella);
  529.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  530.                 sqlQueryObject.addSelectField(tabella +".tipologia");
  531.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE +".nome_porta");
  532.                 sqlQueryObject.setANDLogicOperator(true);
  533.                 sqlQueryObject.addWhereCondition(tabella+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  534.                 sqlQueryObject.addWhereCondition(tabella+".tipo=?");
  535.                 queryString = sqlQueryObject.createSQLQuery();
  536.                 stmt = con.prepareStatement(queryString);
  537.                 stmt.setString(1, tipo);
  538.                 risultato = stmt.executeQuery();
  539.                 while (risultato.next()){
  540.                     String tipologia = risultato.getString("tipologia");
  541.                     String nome = risultato.getString("nome_porta");
  542.                     String labelMessaggio = formatMessageHandlerFromTipologia(tipologia);
  543.                     
  544.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  545.                     if(resultPorta.mapping) {
  546.                         messageHandlerPD_mapping_list.add(resultPorta.label + ": " + labelMessaggio);
  547.                     }
  548.                     else {
  549.                         messageHandlerPD_list.add(resultPorta.label + ": " + labelMessaggio);
  550.                     }
  551.                     isInUso = true;
  552.                 }
  553.                 risultato.close();
  554.                 stmt.close();
  555.                 
  556.             }else if("SERVICE_HANDLER".equals(tipoPlugin)) {
  557.                 List<String> serviceHandler_list = whereIsInUso.get(ErrorsHandlerCostant.SERVICE_HANDLER);
  558.                 
  559.                 if (serviceHandler_list == null) {
  560.                     serviceHandler_list = new ArrayList<>();
  561.                     whereIsInUso.put(ErrorsHandlerCostant.SERVICE_HANDLER, serviceHandler_list);
  562.                 }
  563.                 
  564.                 // config handlers
  565.                 String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  566.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  567.                 sqlQueryObject.addFromTable(tabella);
  568.                 sqlQueryObject.addSelectField(tabella +".tipologia");
  569.                 sqlQueryObject.setANDLogicOperator(true);
  570.                 sqlQueryObject.addWhereCondition(tabella +".tipo=?");
  571.                 queryString = sqlQueryObject.createSQLQuery();
  572.                 stmt = con.prepareStatement(queryString);
  573.                 stmt.setString(1, tipo);
  574.                 risultato = stmt.executeQuery();
  575.                 while (risultato.next()){
  576.                     String tipologia = risultato.getString("tipologia");
  577.                     String labelMessaggio = formatServiceHandlerFromTipologia(tipologia);
  578.                     serviceHandler_list.add(labelMessaggio);
  579.                     isInUso = true;
  580.                 }
  581.                 risultato.close();
  582.                 stmt.close();
  583.             }
  584.             else if("TOKEN_DYNAMIC_DISCOVERY".equals(tipoPlugin)
  585.                     ||
  586.                 "TOKEN_VALIDAZIONE".equals(tipoPlugin)
  587.                 ||
  588.                 "TOKEN_NEGOZIAZIONE".equals(tipoPlugin)
  589.                 ||
  590.                 "ATTRIBUTE_AUTHORITY".equals(tipoPlugin) ) {
  591.                 
  592.                 boolean tokenDynamicDiscovery = "TOKEN_DYNAMIC_DISCOVERY".equals(tipoPlugin);
  593.                 boolean tokenValidazione = "TOKEN_VALIDAZIONE".equals(tipoPlugin);
  594.                 boolean tokenNegoziazione = "TOKEN_NEGOZIAZIONE".equals(tipoPlugin);
  595.                 boolean attributeAuthority = "ATTRIBUTE_AUTHORITY".equals(tipoPlugin);
  596.                 
  597.                 ErrorsHandlerCostant constants = null;
  598.                 String tipologia = null;
  599.                 if(tokenDynamicDiscovery) {
  600.                     constants = ErrorsHandlerCostant.TOKEN_DYNAMIC_DISCOVERY_PA;
  601.                     tipologia = CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION;
  602.                 }
  603.                 else if(tokenValidazione) {
  604.                     constants = ErrorsHandlerCostant.TOKEN_PA;
  605.                     tipologia = CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION;
  606.                 }
  607.                 else if(tokenNegoziazione) {
  608.                     constants = ErrorsHandlerCostant.TOKEN_NEGOZIAZIONE_PA;
  609.                     tipologia = CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE;
  610.                 }
  611.                 else {
  612.                     constants = ErrorsHandlerCostant.ATTRIBUTE_AUTHORITY_PA;
  613.                     tipologia = CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY;
  614.                 }
  615.                                 
  616.                 List<String> gpList = whereIsInUso.get(constants);
  617.                 if (gpList == null) {
  618.                     gpList = new ArrayList<>();
  619.                     whereIsInUso.put(constants, gpList);
  620.                 }   
  621.                 
  622.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  623.                 sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTIES, "gps");
  624.                 sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTY, "gp");
  625.                 sqlQueryObject.setSelectDistinct(true);
  626.                 sqlQueryObject.addSelectAliasField("gps", "nome", "nomeGP");
  627.                 sqlQueryObject.setANDLogicOperator(true);
  628.                 sqlQueryObject.addWhereCondition("gps.id=gp.id_props");
  629.                 sqlQueryObject.addWhereCondition("gps.tipologia=?");
  630.                 String campoGpNome = "gp.nome=?";
  631.                 String campoGpValore = "gp.valore";
  632.                 if(tokenValidazione) {
  633.                     sqlQueryObject.addWhereCondition(false, campoGpNome, campoGpNome, campoGpNome);
  634.                     sqlQueryObject.addWhereLikeCondition(campoGpValore, tipo, false, false, false);
  635.                 }
  636.                 else if(tokenDynamicDiscovery || tokenNegoziazione || attributeAuthority) {
  637.                     sqlQueryObject.addWhereCondition(campoGpNome);
  638.                     sqlQueryObject.addWhereLikeCondition(campoGpValore, tipo, false, false, false);
  639.                 }
  640.                 
  641.                 queryString = sqlQueryObject.createSQLQuery();
  642.                 stmt = con.prepareStatement(queryString);
  643.                 int index = 1;
  644.                 JDBCParameterUtilities utils = new JDBCParameterUtilities(sqlQueryObject.getTipoDatabaseOpenSPCoop2());
  645.                 utils.setParameter(stmt, index++, tipologia, String.class);
  646.                 if(tokenValidazione) {
  647.                     utils.setParameter(stmt, index++, CostantiConfigurazione.POLICY_VALIDAZIONE_CLAIMS_PARSER_PLUGIN_TYPE, String.class);
  648.                     utils.setParameter(stmt, index++, CostantiConfigurazione.POLICY_INTROSPECTION_CLAIMS_PARSER_PLUGIN_TYPE, String.class);
  649.                     utils.setParameter(stmt, index++, CostantiConfigurazione.POLICY_USER_INFO_CLAIMS_PARSER_PLUGIN_TYPE, String.class);
  650.                 }
  651.                 else if(tokenDynamicDiscovery) {
  652.                     utils.setParameter(stmt, index++, CostantiConfigurazione.POLICY_DYNAMIC_DISCOVERY_CLAIMS_PARSER_PLUGIN_TYPE, String.class);
  653.                 }
  654.                 else if(tokenNegoziazione) {
  655.                     utils.setParameter(stmt, index++, CostantiConfigurazione.POLICY_RETRIEVE_TOKEN_PARSER_PLUGIN_TYPE, String.class);
  656.                 }
  657.                 else if(attributeAuthority) {
  658.                     utils.setParameter(stmt, index++, CostantiConfigurazione.AA_RESPONSE_PARSER_PLUGIN_TYPE, String.class);
  659.                 }
  660.                 risultato = stmt.executeQuery();
  661.                 while (risultato.next()) {
  662.                     
  663.                     String nome = risultato.getString("nomeGP");
  664.                     
  665.                     String labelMessaggio = DBOggettiInUsoUtils.formatGenericProperties(tipologia, nome);
  666.                     gpList.add(labelMessaggio);
  667.     
  668.                     isInUso = true;
  669.                 }
  670.                 risultato.close();
  671.                 stmt.close();
  672.             }
  673.             
  674.             return isInUso;

  676.         } catch (Exception se) {
  677.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  678.         } finally {
  679.             // Chiudo statement and resultset
  680.             JDBCUtilities.closeResources(risultato2, stmt2);
  681.             JDBCUtilities.closeResources(risultato, stmt);
  682.         }
  683.     }

  685.     protected static String toString(String className, String label, String tipoPlugin, String tipo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  686.         
  687.         if(className!=null && tipoPlugin!=null && tipo!=null) {
  688.             // nop
  689.         }
  690.         
  691.         StringBuilder bf = new StringBuilder();
  692.     
  693.         bf.append(label);
  694.         
  695.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  696.         StringBuilder msg = new StringBuilder();
  697.         msg.append("Plugin '" +bf.toString() +"' non eliminabile perch&egrave; :"+separator);
  698.         if(!prefix){
  699.             msg = new StringBuilder();
  700.         }
  701.         String separatorCategorie = "";
  702.         if(whereIsInUso.size()>1) {
  703.             separatorCategorie = separator;
  704.         }
  705.         for (ErrorsHandlerCostant key : keys) {
  706.             List<String> messages = whereIsInUso.get(key);

  708.             if ( messages!=null && !messages.isEmpty()) {
  709.                 msg.append(separatorCategorie);
  710.             }
  711.             
  712.             switch (key) {
  713.             
  714.             case CONNETTORE_MAPPING_PD:
  715.                 if ( messages!=null && !messages.isEmpty()) {
  716.                     msg.append("utilizzata nel connettore per le Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  717.                 }
  718.                 break;
  719.             case CONNETTORE_PD:
  720.                 if ( messages!=null && !messages.isEmpty()) {
  721.                     msg.append("utilizzato nelle Porte Outbound (Connettore): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  722.                 }
  723.                 break;
  724.             case CONNETTORE_MAPPING_PA:
  725.                 if ( messages!=null && !messages.isEmpty()) {
  726.                     msg.append("utilizzato nel connettore per le Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  727.                 }
  728.                 break;
  729.             case CONNETTORE_PA:
  730.                 if ( messages!=null && !messages.isEmpty()) {
  731.                     msg.append("utilizzato nelle Porte Inbound (Connettore): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  732.                 }
  733.                 break;
  734.             
  735.             case AUTENTICAZIONE_MAPPING_PD:
  736.                 if ( messages!=null && !messages.isEmpty()) {
  737.                     msg.append("utilizzato come processo di autenticazione nel Controllo degli Accessi delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  738.                 }
  739.                 break;
  740.             case AUTENTICAZIONE_PD:
  741.                 if ( messages!=null && !messages.isEmpty()) {
  742.                     msg.append("utilizzato nelle Porte Outbound (Controllo degli Accessi - Autenticazione): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  743.                 }
  744.                 break;
  745.             case AUTENTICAZIONE_MAPPING_PA:
  746.                 if ( messages!=null && !messages.isEmpty()) {
  747.                     msg.append("utilizzato come processo di autenticazione nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  748.                 }
  749.                 break;
  750.             case AUTENTICAZIONE_PA:
  751.                 if ( messages!=null && !messages.isEmpty()) {
  752.                     msg.append("utilizzato nelle Porte Inbound (Controllo degli Accessi - Autenticazione): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  753.                 }
  754.                 break;
  755.                 
  756.             case AUTORIZZAZIONE_MAPPING_PD:
  757.                 if ( messages!=null && !messages.isEmpty()) {
  758.                     msg.append("utilizzato come processo di autorizzazione nel Controllo degli Accessi delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  759.                 }
  760.                 break;
  761.             case AUTORIZZAZIONE_PD:
  762.                 if ( messages!=null && !messages.isEmpty()) {
  763.                     msg.append("utilizzato nelle Porte Outbound (Controllo degli Accessi - Autorizzazione): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  764.                 }
  765.                 break;
  766.             case AUTORIZZAZIONE_MAPPING_PA:
  767.                 if ( messages!=null && !messages.isEmpty()) {
  768.                     msg.append("utilizzato come processo di autorizzazione nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  769.                 }
  770.                 break;
  771.             case AUTORIZZAZIONE_PA:
  772.                 if ( messages!=null && !messages.isEmpty()) {
  773.                     msg.append("utilizzato nelle Porte Inbound (Controllo degli Accessi - Autorizzazione): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  774.                 }
  775.                 break;
  776.                 
  777.             case AUTORIZZAZIONE_CONTENUTI_MAPPING_PD:
  778.                 if ( messages!=null && !messages.isEmpty()) {
  779.                     msg.append("utilizzato come processo di autorizzazione dei contenuti nel Controllo degli Accessi delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  780.                 }
  781.                 break;
  782.             case AUTORIZZAZIONE_CONTENUTI_PD:
  783.                 if ( messages!=null && !messages.isEmpty()) {
  784.                     msg.append("utilizzato nelle Porte Outbound (Controllo degli Accessi - Autorizzazione dei Contenuti): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  785.                 }
  786.                 break;
  787.             case AUTORIZZAZIONE_CONTENUTI_MAPPING_PA:
  788.                 if ( messages!=null && !messages.isEmpty()) {
  789.                     msg.append("utilizzato come processo di autorizzazione dei contenuti nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  790.                 }
  791.                 break;
  792.             case AUTORIZZAZIONE_CONTENUTI_PA:
  793.                 if ( messages!=null && !messages.isEmpty()) {
  794.                     msg.append("utilizzato nelle Porte Inbound (Controllo degli Accessi - Autorizzazione dei Contenuti): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  795.                 }
  796.                 break;
  797.                 
  798.             case CONTROLLO_TRAFFICO:
  799.                 if ( messages!=null && !messages.isEmpty() ) {
  800.                     msg.append("utilizzato in Policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  801.                 }
  802.                 break;
  803.                 
  804.             case INTEGRAZIONE_MAPPING_PD:
  805.                 if ( messages!=null && !messages.isEmpty()) {
  806.                     msg.append("utilizzato per generare i metadati di integrazione nelle Opzioni Avanzate delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  807.                 }
  808.                 break;
  809.             case INTEGRAZIONE_PD:
  810.                 if ( messages!=null && !messages.isEmpty()) {
  811.                     msg.append("utilizzato nelle Porte Outbound (Opzioni Avanzate - Metadata di Integrazione): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  812.                 }
  813.                 break;
  814.             case INTEGRAZIONE_MAPPING_PA:
  815.                 if ( messages!=null && !messages.isEmpty()) {
  816.                     msg.append("utilizzato per generare i metadati di integrazione nelle Opzioni Avanzate delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  817.                 }
  818.                 break;
  819.             case INTEGRAZIONE_PA:
  820.                 if ( messages!=null && !messages.isEmpty()) {
  821.                     msg.append("utilizzato nelle Porte Inbound (Opzioni Avanzate - Metadata di Integrazione): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  822.                 }
  823.                 break;
  824.                 
  825.             case BEHAVIOUR_MAPPING_PA:
  826.                 if ( messages!=null && !messages.isEmpty()) {
  827.                     msg.append("utilizzato nella configurazione dei connettori multipli come consegna personalizzata delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  828.                 }
  829.                 break;
  830.             case BEHAVIOUR_PA:
  831.                 if ( messages!=null && !messages.isEmpty()) {
  832.                     msg.append("utilizzato nelle Porte Inbound (Connettori Multipli - Consegna Personalizzata): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  833.                 }
  834.                 break;
  835.                 
  836.             case ALLARMI_MAPPING_PA:
  837.                 if ( messages!=null && !messages.isEmpty()) {
  838.                     msg.append("utilizzato negli Allarmi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  839.                 }
  840.                 break;
  841.             case ALLARMI_PA:
  842.                 if ( messages!=null && !messages.isEmpty()) {
  843.                     msg.append("utilizzato nelle Porte Inbound (Allarmi): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  844.                 }
  845.                 break;
  846.             case ALLARMI_MAPPING_PD:
  847.                 if ( messages!=null && !messages.isEmpty()) {
  848.                     msg.append("utilizzato negli Allarmi delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  849.                 }
  850.                 break;
  851.             case ALLARMI_PD:
  852.                 if ( messages!=null && !messages.isEmpty()) {
  853.                     msg.append("utilizzato nelle Porte Outbound (Allarmi): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  854.                 }
  855.                 break;
  856.             case ALLARMI:
  857.                 if ( messages!=null && !messages.isEmpty() ) {
  858.                     msg.append("utilizzato negli Allarmi definiti nella configurazione generale: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  859.                 }
  860.                 break;
  861.             case MESSAGE_HANDLER_MAPPING_PA:
  862.                 if ( messages!=null && !messages.isEmpty()) {
  863.                     msg.append("utilizzato nei Message Handlers delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  864.                 }
  865.                 break;
  866.             case MESSAGE_HANDLER_PA:
  867.                 if ( messages!=null && !messages.isEmpty()) {
  868.                     msg.append("utilizzato nelle Porte Inbound (Message Handlers): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  869.                 }
  870.                 break;
  871.             case MESSAGE_HANDLER:
  872.                 if ( messages!=null && !messages.isEmpty() ) {
  873.                     msg.append("utilizzato nei Message Handlers: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  874.                 }
  875.                 break;
  876.             case MESSAGE_HANDLER_MAPPING_PD:
  877.                 if ( messages!=null && !messages.isEmpty()) {
  878.                     msg.append("utilizzato nei Message Handlers delle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  879.                 }
  880.                 break;
  881.             case MESSAGE_HANDLER_PD:
  882.                 if ( messages!=null && !messages.isEmpty()) {
  883.                     msg.append("utilizzato nelle Porte Outbound (Message Handlers): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  884.                 }
  885.                 break;
  886.             case SERVICE_HANDLER:
  887.                 if ( messages!=null && !messages.isEmpty() ) {
  888.                     msg.append("utilizzato nei Service Handlers: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  889.                 }
  890.                 break;
  891.                 
  892.             case TOKEN_DYNAMIC_DISCOVERY_PA:
  893.                 if ( messages!=null && !messages.isEmpty() ) {
  894.                     msg.append("utilizzato nelle Token Policy di Validazione: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  895.                 }
  896.                 break;  
  897.             case TOKEN_PA:
  898.                 if ( messages!=null && !messages.isEmpty() ) {
  899.                     msg.append("utilizzato nelle Token Policy di Validazione: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  900.                 }
  901.                 break;  
  902.             case TOKEN_NEGOZIAZIONE_PA:
  903.                 if ( messages!=null && !messages.isEmpty() ) {
  904.                     msg.append("utilizzato nelle Token Policy di Negoziazione: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  905.                 }
  906.                 break;  
  907.             case ATTRIBUTE_AUTHORITY_PA:
  908.                 if ( messages!=null && !messages.isEmpty() ) {
  909.                     msg.append("utilizzato negli Attribute Authority: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  910.                 }
  911.                 break;  
  912.                 
  913.             default:
  914.                 msg.append("utilizzato in oggetto non codificato ("+key+")"+separator);
  915.                 break;
  916.             }

  918.         }// chiudo for

  920.         return msg.toString();
  921.     }

  923.     private static String formatMessageHandlerFromTipologia(String tipologia) {
  924.         if(tipologia.endsWith(CostantiDB.HANDLER_REQUEST_SUFFIX)) {
  925.             String tipologiaWS = tipologia.substring(0, tipologia.indexOf(CostantiDB.HANDLER_REQUEST_SUFFIX));
  926.             String template = "Fase [{0}] degli Handler di Richiesta";
  927.             return MessageFormat.format(template, tipologiaWS);
  928.         } else {
  929.             String tipologiaWS = tipologia.substring(0, tipologia.indexOf(CostantiDB.HANDLER_RESPONSE_SUFFIX));
  930.             String template = "Fase [{0}] degli Handler di Risposta";
  931.             return MessageFormat.format(template, tipologiaWS);
  932.         }
  933.     }
  934.     
  935.     private static String formatServiceHandlerFromTipologia(String tipologia) {
  936. /**     String tipologiaWS = tipologia.substring(0, tipologia.indexOf(CostantiDB.HANDLER_REQUEST_SUFFIX));*/
  937.         return MessageFormat.format("Fase [{0}]", tipologia);
  938.         
  939.     }
  940.     
  941. }
Created with JaCoCo 0.8.8.202204050719