DBOggettiInUsoUtils_ruoli.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.constants.CostantiDB;
  34. import org.openspcoop2.core.id.IDRuolo;
  35. import org.openspcoop2.core.id.IDSoggetto;
  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_ruoli
  44.  * 
  45.  * @author Andrea Poli (apoli@link.it)
  46.  * @author $Author$
  47.  * @version $Rev$, $Date$
  48.  * 
  49.  */
  50. public class DBOggettiInUsoUtils_ruoli {

  52.     protected static boolean isRuoloConfigInUso(Connection con, String tipoDB, IDRuolo idRuolo, Map<ErrorsHandlerCostant, 
  53.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  54.         return _isRuoloInUso(con,tipoDB,idRuolo,false,true,whereIsInUso,normalizeObjectIds);
  55.     }
  56.     protected static boolean isRuoloRegistryInUso(Connection con, String tipoDB, IDRuolo idRuolo, Map<ErrorsHandlerCostant, 
  57.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  58.         return _isRuoloInUso(con,tipoDB,idRuolo,true,false,whereIsInUso,normalizeObjectIds);
  59.     }
  60.     protected static boolean isRuoloInUso(Connection con, String tipoDB, IDRuolo idRuolo, Map<ErrorsHandlerCostant, 
  61.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  62.         return _isRuoloInUso(con,tipoDB,idRuolo,true,true,whereIsInUso,normalizeObjectIds);
  63.     }
  64.     private static boolean _isRuoloInUso(Connection con, String tipoDB, IDRuolo idRuolo, boolean registry, boolean config, Map<ErrorsHandlerCostant, 
  65.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  66.         String nomeMetodo = "_isRuoloInUso";

  68.         PreparedStatement stmt = null;
  69.         ResultSet risultato = null;
  70.         String queryString;

  72.         try {

  74.             long idR = DBUtils.getIdRuolo(idRuolo, con, tipoDB);
  75.             
  76.             boolean isInUso = false;
  77.             
  78.             List<String> soggetti_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_SOGGETTI);
  79.             List<String> servizi_applicativi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_SERVIZI_APPLICATIVI);
  80.             List<String> porte_applicative_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  81.             List<String> porte_applicative_modi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE_MODI);
  82.             List<String> porte_delegate_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE);
  83.             List<String> mappingErogazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  84.             List<String> mappingErogazionePA_modi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA_MODI);
  85.             List<String> mappingFruizionePD_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD);
  86.             List<String> porte_applicative_token_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PA);
  87.             List<String> porte_applicative_token_modi_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PA_MODI);
  88.             List<String> porte_delegate_token_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PD);
  89.             List<String> mappingErogazioneTokenPA_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA);
  90.             List<String> mappingErogazioneTokenPA_modi_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA_MODI);
  91.             List<String> mappingFruizioneTokenPD_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PD);
  92.             List<String> ct_list = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  93.             List<String> allarme_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI);
  94.             
  95.             if (soggetti_list == null) {
  96.                 soggetti_list = new ArrayList<>();
  97.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_SOGGETTI, soggetti_list);
  98.             }
  99.             if (servizi_applicativi_list == null) {
  100.                 servizi_applicativi_list = new ArrayList<>();
  101.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_SERVIZI_APPLICATIVI, servizi_applicativi_list);
  102.             }
  103.             
  104.             if (porte_applicative_list == null) {
  105.                 porte_applicative_list = new ArrayList<>();
  106.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porte_applicative_list);
  107.             }
  108.             if (porte_applicative_modi_list == null) {
  109.                 porte_applicative_modi_list = new ArrayList<>();
  110.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE_MODI, porte_applicative_modi_list);
  111.             }
  112.             if (porte_delegate_list == null) {
  113.                 porte_delegate_list = new ArrayList<>();
  114.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE, porte_delegate_list);
  115.             }
  116.             if (mappingErogazionePA_list == null) {
  117.                 mappingErogazionePA_list = new ArrayList<>();
  118.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePA_list);
  119.             }
  120.             if (mappingErogazionePA_modi_list == null) {
  121.                 mappingErogazionePA_modi_list = new ArrayList<>();
  122.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA_MODI, mappingErogazionePA_modi_list);
  123.             }
  124.             if (mappingFruizionePD_list == null) {
  125.                 mappingFruizionePD_list = new ArrayList<>();
  126.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePD_list);
  127.             }
  128.             
  129.             if (porte_applicative_token_list == null) {
  130.                 porte_applicative_token_list = new ArrayList<>();
  131.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PA, porte_applicative_token_list);
  132.             }
  133.             if (porte_applicative_token_modi_list == null) {
  134.                 porte_applicative_token_modi_list = new ArrayList<>();
  135.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PA_MODI, porte_applicative_token_modi_list);
  136.             }
  137.             if (porte_delegate_token_list == null) {
  138.                 porte_delegate_token_list = new ArrayList<>();
  139.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PD, porte_delegate_token_list);
  140.             }
  141.             if (mappingErogazioneTokenPA_list == null) {
  142.                 mappingErogazioneTokenPA_list = new ArrayList<>();
  143.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA, mappingErogazioneTokenPA_list);
  144.             }
  145.             if (mappingErogazioneTokenPA_modi_list == null) {
  146.                 mappingErogazioneTokenPA_modi_list = new ArrayList<>();
  147.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA_MODI, mappingErogazioneTokenPA_modi_list);
  148.             }
  149.             if (mappingFruizioneTokenPD_list == null) {
  150.                 mappingFruizioneTokenPD_list = new ArrayList<>();
  151.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PD, mappingFruizioneTokenPD_list);
  152.             }
  153.             
  154.             if (ct_list == null) {
  155.                 ct_list = new ArrayList<>();
  156.                 whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ct_list);
  157.             }
  158.             if (allarme_list == null) {
  159.                 allarme_list = new ArrayList<>();
  160.                 whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarme_list);
  161.             }
  162.             
  163.             
  164.             // Controllo che il ruolo non sia in uso nei soggetti
  165.             if(registry){
  166.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  167.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI_RUOLI);
  168.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  169.                 sqlQueryObject.addSelectField("tipo_soggetto");
  170.                 sqlQueryObject.addSelectField("nome_soggetto");
  171.                 sqlQueryObject.setANDLogicOperator(true);
  172.                 sqlQueryObject.setSelectDistinct(true);
  173.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI_RUOLI+".id_ruolo = ?");
  174.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI_RUOLI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  175.                 queryString = sqlQueryObject.createSQLQuery();
  176.                 stmt = con.prepareStatement(queryString);
  177.                 stmt.setLong(1, idR);
  178.                 risultato = stmt.executeQuery();
  179.                 while (risultato.next()) {
  180.                     String tipo_soggetto = risultato.getString("tipo_soggetto");
  181.                     String nome_soggetto = risultato.getString("nome_soggetto");
  182.                     IDSoggetto idSoggetto = new IDSoggetto(tipo_soggetto, nome_soggetto);
  183.                     if(normalizeObjectIds) {
  184.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(tipo_soggetto);
  185.                         soggetti_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelSoggetto(protocollo, idSoggetto));
  186.                     }
  187.                     else {
  188.                         soggetti_list.add(tipo_soggetto + "/" + nome_soggetto); 
  189.                     }
  190.                     isInUso = true;
  191.                 }
  192.                 risultato.close();
  193.                 stmt.close();

  195.             }
  196.             
  197.             // Controllo che il ruolo non sia in uso nei serviziApplicativi
  198.             if(config){
  199.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  200.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI_RUOLI);
  201.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  202.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  203.                 sqlQueryObject.addSelectField("tipo_soggetto");
  204.                 sqlQueryObject.addSelectField("nome_soggetto");
  205.                 sqlQueryObject.addSelectField(CostantiDB.SERVIZI_APPLICATIVI+".nome");
  206.                 sqlQueryObject.setANDLogicOperator(true);
  207.                 sqlQueryObject.setSelectDistinct(true);
  208.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_RUOLI+".ruolo = ?");
  209.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI_RUOLI+".id_servizio_applicativo = "+CostantiDB.SERVIZI_APPLICATIVI+".id");
  210.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  211.                 queryString = sqlQueryObject.createSQLQuery();
  212.                 stmt = con.prepareStatement(queryString);
  213.                 stmt.setString(1, idRuolo.getNome());
  214.                 risultato = stmt.executeQuery();
  215.                 while (risultato.next()) {
  216.                     String tipo_soggetto = risultato.getString("tipo_soggetto");
  217.                     String nome_soggetto = risultato.getString("nome_soggetto");
  218.                     String nome = risultato.getString("nome");
  219.                     IDSoggetto idSoggetto = new IDSoggetto(tipo_soggetto, nome_soggetto);
  220.                     if(normalizeObjectIds) {
  221.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(tipo_soggetto);
  222.                         servizi_applicativi_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+nome+DBOggettiInUsoUtils.getSubjectSuffix(protocollo, idSoggetto));
  223.                     }
  224.                     else {
  225.                         servizi_applicativi_list.add(tipo_soggetto + "/" + nome_soggetto+"_"+nome);
  226.                     }
  227.                     isInUso = true;
  228.                 }
  229.                 risultato.close();
  230.                 stmt.close();
  231.             }
  232.             
  233.             // Controllo che il ruolo non sia in uso nelle porte applicative
  234.             if(config){
  235.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  236.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_RUOLI);
  237.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  238.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  239.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  240.                 sqlQueryObject.setANDLogicOperator(true);
  241.                 sqlQueryObject.setSelectDistinct(true);
  242.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_RUOLI+".ruolo = ?");
  243.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_RUOLI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  244.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  245.                 queryString = sqlQueryObject.createSQLQuery();
  246.                 stmt = con.prepareStatement(queryString);
  247.                 stmt.setString(1, idRuolo.getNome());
  248.                 risultato = stmt.executeQuery();
  249.                 while (risultato.next()) {
  250.                     String nome = risultato.getString("nome_porta");
  251.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  252.                     if(resultPorta.mapping) {
  253.                         if(resultPorta.erogazioneModi)
  254.                             mappingErogazionePA_modi_list.add(resultPorta.label);
  255.                         else
  256.                             mappingErogazionePA_list.add(resultPorta.label);
  257.                     }
  258.                     else {
  259.                         if(resultPorta.erogazioneModi)
  260.                             porte_applicative_modi_list.add(resultPorta.label);
  261.                         else
  262.                             porte_applicative_list.add(resultPorta.label);
  263.                     }
  264.                     isInUso = true;
  265.                 }
  266.                 risultato.close();
  267.                 stmt.close();
  268.             }
  269.             
  270.             // Controllo che il ruolo non sia in uso nelle porte applicative (token)
  271.             if(config){
  272.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  273.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI);
  274.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  275.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  276.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  277.                 sqlQueryObject.setANDLogicOperator(true);
  278.                 sqlQueryObject.setSelectDistinct(true);
  279.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI+".ruolo = ?");
  280.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  281.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  282.                 queryString = sqlQueryObject.createSQLQuery();
  283.                 stmt = con.prepareStatement(queryString);
  284.                 stmt.setString(1, idRuolo.getNome());
  285.                 risultato = stmt.executeQuery();
  286.                 while (risultato.next()) {
  287.                     String nome = risultato.getString("nome_porta");
  288.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  289.                     if(resultPorta.mapping) {
  290.                         if(resultPorta.erogazioneModi)
  291.                             mappingErogazioneTokenPA_modi_list.add(resultPorta.label);
  292.                         else
  293.                             mappingErogazioneTokenPA_list.add(resultPorta.label);
  294.                     }
  295.                     else {
  296.                         if(resultPorta.erogazioneModi)
  297.                             porte_applicative_token_modi_list.add(resultPorta.label);
  298.                         else
  299.                             porte_applicative_token_list.add(resultPorta.label);
  300.                     }
  301.                     isInUso = true;
  302.                 }
  303.                 risultato.close();
  304.                 stmt.close();
  305.             }
  306.             
  307.             // Controllo che il ruolo non sia in uso nelle porte delegate
  308.             if(config){
  309.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  310.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_RUOLI);
  311.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  312.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  313.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  314.                 sqlQueryObject.setANDLogicOperator(true);
  315.                 sqlQueryObject.setSelectDistinct(true);
  316.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_RUOLI+".ruolo = ?");
  317.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_RUOLI+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  318.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  319.                 queryString = sqlQueryObject.createSQLQuery();
  320.                 stmt = con.prepareStatement(queryString);
  321.                 stmt.setString(1, idRuolo.getNome());
  322.                 risultato = stmt.executeQuery();
  323.                 while (risultato.next()) {
  324.                     String nome = risultato.getString("nome_porta");
  325.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  326.                     if(resultPorta.mapping) {
  327.                         mappingFruizionePD_list.add(resultPorta.label);
  328.                     }
  329.                     else {
  330.                         porte_delegate_list.add(resultPorta.label);
  331.                     }
  332.                     isInUso = true;
  333.                 }
  334.                 risultato.close();
  335.                 stmt.close();
  336.             }
  337.             
  338.             // Controllo che il ruolo non sia in uso nelle porte delegate (token)
  339.             if(config){
  340.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  341.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI);
  342.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  343.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  344.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  345.                 sqlQueryObject.setANDLogicOperator(true);
  346.                 sqlQueryObject.setSelectDistinct(true);
  347.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI+".ruolo = ?");
  348.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TOKEN_RUOLI+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  349.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  350.                 queryString = sqlQueryObject.createSQLQuery();
  351.                 stmt = con.prepareStatement(queryString);
  352.                 stmt.setString(1, idRuolo.getNome());
  353.                 risultato = stmt.executeQuery();
  354.                 while (risultato.next()) {
  355.                     String nome = risultato.getString("nome_porta");
  356.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  357.                     if(resultPorta.mapping) {
  358.                         mappingFruizioneTokenPD_list.add(resultPorta.label);
  359.                     }
  360.                     else {
  361.                         porte_delegate_token_list.add(resultPorta.label);
  362.                     }
  363.                     isInUso = true;
  364.                 }
  365.                 risultato.close();
  366.                 stmt.close();
  367.             }
  368.             
  369.             // Controllo che il soggetto non sia associato a policy di controllo del traffico o allarmi
  370.             if(config){
  371.                 
  372.                 int max = 2;
  373.                 if(!CostantiDB.isAllarmiEnabled()) {
  374.                     max=1;
  375.                 }
  376.                 
  377.                 for (int i = 0; i < max; i++) {
  378.                     
  379.                     String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  380.                     String identificativo_column = "active_policy_id";
  381.                     String alias_column = "policy_alias";
  382.                     List<String> list = ct_list;
  383.                     String oggetto = "Policy";
  384.                     if(i==1) {
  385.                         tabella = CostantiDB.ALLARMI;
  386.                         identificativo_column = "nome";
  387.                         alias_column = "alias";
  388.                         list = allarme_list;
  389.                         oggetto = "Allarme";
  390.                     }
  391.                 
  392.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  393.                     sqlQueryObject.addFromTable(tabella);
  394.                     sqlQueryObject.addSelectField(identificativo_column);
  395.                     sqlQueryObject.addSelectField(alias_column);
  396.                     sqlQueryObject.addSelectField("filtro_ruolo");
  397.                     sqlQueryObject.addSelectField("filtro_porta");
  398.                     sqlQueryObject.setANDLogicOperator(false); // OR
  399.                     sqlQueryObject.addWhereCondition(true, 
  400.                             tabella+".filtro_ruolo_fruitore = ?");
  401.                     sqlQueryObject.addWhereCondition(true, 
  402.                             tabella+".filtro_ruolo_erogatore = ?");
  403.                     queryString = sqlQueryObject.createSQLQuery();
  404.                     sqlQueryObject.addOrderBy("filtro_ruolo");
  405.                     sqlQueryObject.addOrderBy("filtro_porta");
  406.                     stmt = con.prepareStatement(queryString);
  407.                     int index = 1;
  408.                     stmt.setString(index++, idRuolo.getNome());
  409.                     stmt.setString(index++, idRuolo.getNome());
  410.                     risultato = stmt.executeQuery();
  411.                     while (risultato.next()) {
  412.                         
  413.                         String alias = risultato.getString(alias_column);
  414.                         if(alias== null || "".equals(alias)) {
  415.                             alias = risultato.getString(identificativo_column);
  416.                         }
  417.                         
  418.                         String nomePorta = risultato.getString("filtro_porta");
  419.                         String filtro_ruolo = risultato.getString("filtro_ruolo");
  420.                         if(nomePorta!=null) {
  421.                             String tipo = null;
  422.                             String label = null;
  423.                             if("delegata".equals(filtro_ruolo)) {
  424.                                 try {
  425.                                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  426.                                     if(resultPorta.mapping) {
  427.                                         label = "Fruizione di Servizio "+ resultPorta.label;
  428.                                     }
  429.                                 }catch(Exception e) {
  430.                                     tipo = "Outbound";
  431.                                 }
  432.                             }
  433.                             else if("applicativa".equals(filtro_ruolo)) {
  434.                                 try {
  435.                                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  436.                                     if(resultPorta.mapping) {
  437.                                         label = "Erogazione di Servizio "+ resultPorta.label;
  438.                                     }
  439.                                 }catch(Exception e) {
  440.                                     tipo = "Inbound";
  441.                                 }
  442.                             }
  443.                             else {
  444.                                 tipo = filtro_ruolo;
  445.                             }
  446.                             if(label==null) {
  447.                                 list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  448.                             }
  449.                             else {
  450.                                 list.add(oggetto+" '"+alias+"' attiva nella "+label);
  451.                             }
  452.                         }
  453.                         else {
  454.                             list.add(oggetto+" '"+alias+"'");
  455.                         }
  456.         
  457.                         isInUso = true;
  458.                     }
  459.                     risultato.close();
  460.                     stmt.close();
  461.                     
  462.                 }
  463.                 
  464.             }
  465.             
  466.             return isInUso;

  468.         } catch (Exception se) {
  469.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  470.         } finally {
  471.             // Chiudo statement and resultset
  472.             JDBCUtilities.closeResources(risultato, stmt);
  473.         }
  474.     }


  477.     protected static String toString(IDRuolo idRuolo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  478.         return toString(idRuolo, whereIsInUso, prefix, separator," non eliminabile perch&egrave; :");
  479.     }
  480.     protected static String toString(IDRuolo idRuolo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  481.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  482.         String msg = "Ruolo '"+idRuolo.getNome()+"'" + intestazione+separator;
  483.         if(prefix==false){
  484.             msg = "";
  485.         }
  486.         String separatorCategorie = "";
  487.         if(whereIsInUso.size()>1) {
  488.             separatorCategorie = separator;
  489.         }
  490.         for (ErrorsHandlerCostant key : keys) {
  491.             List<String> messages = whereIsInUso.get(key);

  493.             if ( messages!=null && messages.size() > 0) {
  494.                 msg += separatorCategorie;
  495.             }
  496.             
  497.             switch (key) {
  498.             case IN_USO_IN_SOGGETTI:
  499.                 if ( messages!=null && messages.size() > 0) {
  500.                     msg += "utilizzato nei Soggetti: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  501.                 }
  502.                 break;
  503.             case IN_USO_IN_SERVIZI_APPLICATIVI:
  504.                 if ( messages!=null && messages.size() > 0) {
  505.                     msg += "utilizzato negli Applicativi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  506.                 }
  507.                 break;
  508.                 
  509.             case IN_USO_IN_PORTE_APPLICATIVE:
  510.                 if ( messages!=null && messages.size() > 0) {
  511.                     msg += "utilizzato nelle Porte Inbound (Controllo Accessi - Autorizzazione Trasporto): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  512.                 }
  513.                 break;
  514.             case IN_USO_IN_PORTE_APPLICATIVE_MODI:
  515.                 if ( messages!=null && messages.size() > 0) {
  516.                     msg += "utilizzato nelle Porte Inbound (Controllo Accessi - Autorizzazione Canale): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  517.                 }
  518.                 break;
  519.             case IN_USO_IN_PORTE_DELEGATE:
  520.                 if ( messages!=null && messages.size() > 0) {
  521.                     msg += "utilizzato nelle Porte Outbound (Controllo Accessi - Autorizzazione Trasporto): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  522.                 }
  523.                 break;
  524.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  525.                 if ( messages!=null && messages.size() > 0) {
  526.                     msg += "utilizzato nelle Erogazioni (Controllo Accessi - Autorizzazione Trasporto): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  527.                 }
  528.                 break;
  529.             case IN_USO_IN_MAPPING_EROGAZIONE_PA_MODI:
  530.                 if ( messages!=null && messages.size() > 0) {
  531.                     msg += "utilizzato nelle Erogazioni (Controllo Accessi - Autorizzazione Canale): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  532.                 }
  533.                 break;
  534.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  535.                 if ( messages!=null && messages.size() > 0) {
  536.                     msg += "utilizzato nelle Fruizioni (Controllo Accessi - Autorizzazione Trasporto): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  537.                 }
  538.                 break;
  539.                 
  540.             case RUOLI_TOKEN_PA:
  541.                 if ( messages!=null && messages.size() > 0) {
  542.                     msg += "utilizzato nelle Porte Inbound (Controllo Accessi - Autorizzazione Token): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  543.                 }
  544.                 break;
  545.             case RUOLI_TOKEN_PA_MODI:
  546.                 if ( messages!=null && messages.size() > 0) {
  547.                     msg += "utilizzato nelle Porte Inbound (Controllo Accessi - Autorizzazione Messaggio): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  548.                 }
  549.                 break;
  550.             case RUOLI_TOKEN_PD:
  551.                 if ( messages!=null && messages.size() > 0) {
  552.                     msg += "utilizzato nelle Porte Outbound (Controllo Accessi - Autorizzazione Token): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  553.                 }
  554.                 break;
  555.             case RUOLI_TOKEN_MAPPING_PA:
  556.                 if ( messages!=null && messages.size() > 0) {
  557.                     msg += "utilizzato nelle Erogazioni (Controllo Accessi - Autorizzazione Token): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  558.                 }
  559.                 break;
  560.             case RUOLI_TOKEN_MAPPING_PA_MODI:
  561.                 if ( messages!=null && messages.size() > 0) {
  562.                     msg += "utilizzato nelle Erogazioni (Controllo Accessi - Autorizzazione Messaggio): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  563.                 }
  564.                 break;
  565.             case RUOLI_TOKEN_MAPPING_PD:
  566.                 if ( messages!=null && messages.size() > 0) {
  567.                     msg += "utilizzato nelle Fruizioni (Controllo Accessi - Autorizzazione Token): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  568.                 }
  569.                 break;
  570.                 
  571.             case CONTROLLO_TRAFFICO:
  572.                 if ( messages!=null && messages.size() > 0 ) {
  573.                     msg += "utilizzato in Policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  574.                 }
  575.                 break;
  576.             case ALLARMI:
  577.                 if ( messages!=null && messages.size() > 0 ) {
  578.                     msg += "utilizzato in Allarmi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  579.                 }
  580.                 break;
  581.             default:
  582.                 msg += "utilizzato in oggetto non codificato ("+key+")"+separator;
  583.                 break;
  584.             }

  586.         }// chiudo for

  588.         return msg;
  589.     }

  591.     
  592. }
Created with JaCoCo 0.8.8.202204050719