DBOggettiInUsoUtils_soggetti.java

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

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

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

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

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

  58.     protected static boolean isSoggettoConfigInUso(Connection con, String tipoDB, IDSoggetto idSoggettoConfig, boolean checkControlloTraffico, 
  59.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds,
  60.             boolean verificaRuoli) throws UtilsException {
  61.         return isSoggettoInUso(con,tipoDB,idSoggettoConfig,null,checkControlloTraffico, whereIsInUso, normalizeObjectIds, verificaRuoli);
  62.     }
  63.     protected static boolean isSoggettoRegistryInUso(Connection con, String tipoDB, IDSoggetto idSoggettoRegistro, boolean checkControlloTraffico, 
  64.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds,
  65.             boolean verificaRuoli) throws UtilsException {
  66.         return isSoggettoInUso(con,tipoDB,null,idSoggettoRegistro,checkControlloTraffico, whereIsInUso, normalizeObjectIds, verificaRuoli);
  67.     }
  68.     private static boolean isSoggettoInUso(Connection con, String tipoDB, IDSoggetto idSoggettoConfig, IDSoggetto idSoggettoRegistro, boolean checkControlloTraffico, 
  69.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds,
  70.             boolean verificaRuoli) throws UtilsException {
  71.         String nomeMetodo = "isSoggettoInUso";

  73.         PreparedStatement stmt = null;
  74.         ResultSet risultato = null;
  75.         String queryString;
  76.         try {
  77.             boolean isInUso = false;

  79.             long idSoggetto = -1;
  80.             String tipoSoggetto = null;
  81.             String nomeSoggetto = null;
  82.             if(idSoggettoRegistro!=null){
  83.                 tipoSoggetto = idSoggettoRegistro.getTipo();
  84.                 nomeSoggetto = idSoggettoRegistro.getNome();

  86.             }else{
  87.                 tipoSoggetto = idSoggettoConfig.getTipo();
  88.                 nomeSoggetto = idSoggettoConfig.getNome();
  89.             }
  90.             idSoggetto = DBUtils.getIdSoggetto(nomeSoggetto, tipoSoggetto, con, tipoDB);
  91.             if(idSoggetto<=0){
  92.                 throw new UtilsException("Soggetto con tipo["+tipoSoggetto+"] e nome["+nomeSoggetto+"] non trovato");
  93.             }

  95.             List<String> servizi_fruitori_list = whereIsInUso.get(ErrorsHandlerCostant.IS_FRUITORE);
  96.             List<String> servizi_applicativi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_SERVIZI_APPLICATIVI);
  97.             List<String> servizi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_SERVIZI);
  98.             List<String> porte_delegate_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE);
  99.             List<String> porte_applicative_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  100.             List<String> mappingErogazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  101.             List<String> mappingFruizionePD_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD);
  102.             List<String> accordi_list = whereIsInUso.get(ErrorsHandlerCostant.IS_REFERENTE);
  103.             List<String> accordi_coop_list = whereIsInUso.get(ErrorsHandlerCostant.IS_REFERENTE_COOPERAZIONE);
  104.             List<String> partecipanti_list = whereIsInUso.get(ErrorsHandlerCostant.IS_PARTECIPANTE_COOPERAZIONE);
  105.             List<String> utenti_list = whereIsInUso.get(ErrorsHandlerCostant.UTENTE);
  106.             List<String> ct_list = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  107.             List<String> allarme_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI);
  108.             List<String> autorizzazionePA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING);
  109.             List<String> autorizzazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.AUTORIZZAZIONE);
  110.             List<String> ruoliPA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_MAPPING);
  111.             List<String> ruoliPA_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI);
  112.             List<String> ruoliTokenPA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA);
  113.             List<String> ruoliTokenPA_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PA);
  114.             List<String> ruoliTokenPA_mapping_modi_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA_MODI);
  115.             List<String> ruoliTokenPA_modi_list = whereIsInUso.get(ErrorsHandlerCostant.RUOLI_TOKEN_PA_MODI);
  116.             List<String> trasformazionePA_mapping_list = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA);
  117.             List<String> trasformazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PA);
  118.             List<String> configurazioniProxyPass_list = whereIsInUso.get(ErrorsHandlerCostant.CONFIGURAZIONE_REGOLE_PROXY_PASS);

  120.             if (servizi_fruitori_list == null) {
  121.                 servizi_fruitori_list = new ArrayList<>();
  122.                 whereIsInUso.put(ErrorsHandlerCostant.IS_FRUITORE, servizi_fruitori_list);
  123.             }
  124.             if (servizi_applicativi_list == null) {
  125.                 servizi_applicativi_list = new ArrayList<>();
  126.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_SERVIZI_APPLICATIVI, servizi_applicativi_list);
  127.             }
  128.             if (servizi_list == null) {
  129.                 servizi_list = new ArrayList<>();
  130.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_SERVIZI, servizi_list);
  131.             }
  132.             if (porte_delegate_list == null) {
  133.                 porte_delegate_list = new ArrayList<>();
  134.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE, porte_delegate_list);
  135.             }
  136.             if (porte_applicative_list == null) {
  137.                 porte_applicative_list = new ArrayList<>();
  138.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porte_applicative_list);
  139.             }
  140.             if (mappingErogazionePA_list == null) {
  141.                 mappingErogazionePA_list = new ArrayList<>();
  142.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePA_list);
  143.             }
  144.             if (mappingFruizionePD_list == null) {
  145.                 mappingFruizionePD_list = new ArrayList<>();
  146.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePD_list);
  147.             }
  148.             if (accordi_list == null) {
  149.                 accordi_list = new ArrayList<>();
  150.                 whereIsInUso.put(ErrorsHandlerCostant.IS_REFERENTE, accordi_list);
  151.             }
  152.             if (accordi_coop_list == null) {
  153.                 accordi_coop_list = new ArrayList<>();
  154.                 whereIsInUso.put(ErrorsHandlerCostant.IS_REFERENTE_COOPERAZIONE, accordi_coop_list);
  155.             }
  156.             if (partecipanti_list == null) {
  157.                 partecipanti_list = new ArrayList<>();
  158.                 whereIsInUso.put(ErrorsHandlerCostant.IS_PARTECIPANTE_COOPERAZIONE, partecipanti_list);
  159.             }
  160.             if (utenti_list == null) {
  161.                 utenti_list = new ArrayList<>();
  162.                 whereIsInUso.put(ErrorsHandlerCostant.UTENTE, utenti_list);
  163.             }
  164.             if (ct_list == null) {
  165.                 ct_list = new ArrayList<>();
  166.                 whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ct_list);
  167.             }
  168.             if (allarme_list == null) {
  169.                 allarme_list = new ArrayList<>();
  170.                 whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarme_list);
  171.             }
  172.             if (autorizzazionePA_mapping_list == null) {
  173.                 autorizzazionePA_mapping_list = new ArrayList<>();
  174.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE_MAPPING, autorizzazionePA_mapping_list);
  175.             }
  176.             if (autorizzazionePA_list == null) {
  177.                 autorizzazionePA_list = new ArrayList<>();
  178.                 whereIsInUso.put(ErrorsHandlerCostant.AUTORIZZAZIONE, autorizzazionePA_list);
  179.             }
  180.             if (ruoliPA_mapping_list == null) {
  181.                 ruoliPA_mapping_list = new ArrayList<>();
  182.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_MAPPING, ruoliPA_mapping_list);
  183.             }
  184.             if (ruoliPA_list == null) {
  185.                 ruoliPA_list = new ArrayList<>();
  186.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI, ruoliPA_list);
  187.             }
  188.             if (ruoliTokenPA_mapping_list == null) {
  189.                 ruoliTokenPA_mapping_list = new ArrayList<>();
  190.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA, ruoliTokenPA_mapping_list);
  191.             }
  192.             if (ruoliTokenPA_list == null) {
  193.                 ruoliTokenPA_list = new ArrayList<>();
  194.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PA, ruoliTokenPA_list);
  195.             }
  196.             if (ruoliTokenPA_mapping_modi_list == null) {
  197.                 ruoliTokenPA_mapping_modi_list = new ArrayList<>();
  198.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_MAPPING_PA_MODI, ruoliTokenPA_mapping_modi_list);
  199.             }
  200.             if (ruoliTokenPA_modi_list == null) {
  201.                 ruoliTokenPA_modi_list = new ArrayList<>();
  202.                 whereIsInUso.put(ErrorsHandlerCostant.RUOLI_TOKEN_PA_MODI, ruoliTokenPA_modi_list);
  203.             }
  204.             if (trasformazionePA_mapping_list == null) {
  205.                 trasformazionePA_mapping_list = new ArrayList<>();
  206.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA, trasformazionePA_mapping_list);
  207.             }
  208.             if (trasformazionePA_list == null) {
  209.                 trasformazionePA_list = new ArrayList<>();
  210.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PA, trasformazionePA_list);
  211.             }
  212.             if (configurazioniProxyPass_list == null) {
  213.                 configurazioniProxyPass_list = new ArrayList<>();
  214.                 whereIsInUso.put(ErrorsHandlerCostant.CONFIGURAZIONE_REGOLE_PROXY_PASS, configurazioniProxyPass_list);
  215.             }


  218.             // Controllo che il soggetto non sia in uso nei servizi applicativi
  219.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  220.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  221.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  222.             sqlQueryObject.addSelectField("tipo_soggetto");
  223.             sqlQueryObject.addSelectField("nome_soggetto");
  224.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI_APPLICATIVI+".nome");
  225.             sqlQueryObject.setANDLogicOperator(true);
  226.             sqlQueryObject.setSelectDistinct(true);
  227.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  228.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_soggetto = ?");
  229.             queryString = sqlQueryObject.createSQLQuery();
  230.             stmt = con.prepareStatement(queryString);
  231.             stmt.setLong(1, idSoggetto);
  232.             risultato = stmt.executeQuery();
  233.             while (risultato.next()) {
  234.                 String tipo_soggetto = risultato.getString("tipo_soggetto");
  235.                 //String nome_soggetto = risultato.getString("nome_soggetto");
  236.                 String nome = risultato.getString("nome");
  237.                 // non serve, essendo di un soggetto specificoIDSoggetto idSoggettoProprietario = new IDSoggetto(tipo_soggetto, nome_soggetto);
  238.                 if(normalizeObjectIds) {
  239.                     String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(tipo_soggetto);
  240.                     servizi_applicativi_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+nome);
  241.                             // non serve, essendo di un soggetto specifico +getSubjectSuffix(protocollo, idSoggettoProprietario));
  242.                 }
  243.                 else {
  244.                     servizi_applicativi_list.add(nome);
  245.                 }
  246.                 isInUso = true;
  247.             }
  248.             risultato.close();
  249.             stmt.close();


  252.             // controllo porte delegate sia per id che per tipo e nome
  253.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  254.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  255.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  256.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  257.             sqlQueryObject.setANDLogicOperator(true);
  258.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  259.             sqlQueryObject.addWhereCondition(false, 
  260.                     "id_soggetto_erogatore = ?", 
  261.                     "(tipo_soggetto_erogatore = ? AND nome_soggetto_erogatore = ?)",
  262.                     "id_soggetto = ?");
  263.             queryString = sqlQueryObject.createSQLQuery();
  264.             stmt = con.prepareStatement(queryString);
  265.             // controllo se soggetto erogatore di porte delegate
  266.             stmt.setLong(1, idSoggetto);
  267.             stmt.setString(2, tipoSoggetto);
  268.             stmt.setString(3, nomeSoggetto);
  269.             // controllo se soggetto proprietario di porte delegate
  270.             stmt.setLong(4, idSoggetto);
  271.             risultato = stmt.executeQuery();
  272.             while (risultato.next()) {
  273.                 String nome = risultato.getString("nome_porta");
  274.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  275.                 if(resultPorta.mapping) {
  276.                     mappingFruizionePD_list.add(resultPorta.label);
  277.                 }
  278.                 else {
  279.                     porte_delegate_list.add(resultPorta.label);
  280.                 }
  281.                 isInUso = true;
  282.             }
  283.             risultato.close();
  284.             stmt.close();



  288.             // controllo se in uso in porte applicative come proprietario della porta o come soggetto virtuale
  289.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  290.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  291.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  292.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  293.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  294.             sqlQueryObject.setANDLogicOperator(true);
  295.             sqlQueryObject.addWhereCondition(false, 
  296.                     "id_soggetto = ?", 
  297.                     "id_soggetto_virtuale = ?", 
  298.                     "(tipo_soggetto_virtuale = ? AND nome_soggetto_virtuale = ?)");     
  299.             queryString = sqlQueryObject.createSQLQuery();
  300.             stmt = con.prepareStatement(queryString);
  301.             stmt.setLong(1, idSoggetto);
  302.             stmt.setLong(2, idSoggetto);
  303.             stmt.setString(3, tipoSoggetto);
  304.             stmt.setString(4, nomeSoggetto);
  305.             risultato = stmt.executeQuery();
  306.             while (risultato.next()) {
  307.                 String nome = risultato.getString("nome_porta");
  308.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  309.                 if(resultPorta.mapping) {
  310.                     mappingErogazionePA_list.add(resultPorta.label);
  311.                 }
  312.                 else {
  313.                     porte_applicative_list.add(resultPorta.label);
  314.                 }
  315.                 isInUso = true;
  316.             }
  317.             risultato.close();
  318.             stmt.close();



  322.             if(idSoggettoRegistro!=null){
  323.                 //controllo se referente
  324.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  325.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  326.                 sqlQueryObject.addSelectField("*");
  327.                 sqlQueryObject.addWhereCondition("id_referente = ?");
  328.                 queryString = sqlQueryObject.createSQLQuery();
  329.                 stmt = con.prepareStatement(queryString);
  330.                 stmt.setLong(1, idSoggetto);
  331.                 risultato = stmt.executeQuery();
  332.                 while (risultato.next()){
  333.                     String nomeAccordo = risultato.getString("nome");
  334.                     Integer versione = risultato.getInt("versione");
  335.                     if(normalizeObjectIds) {
  336.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idSoggettoRegistro.getTipo());
  337.                         IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromValues(nomeAccordo, idSoggettoRegistro, versione); 
  338.                         accordi_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteComune(protocollo, idAccordo));
  339.                     }
  340.                     else {
  341.                         StringBuilder bf = new StringBuilder();
  342.                         bf.append(idSoggettoRegistro.toString());
  343.                         bf.append(":");
  344.                         bf.append(nomeAccordo);
  345.                         if(versione!=null){
  346.                             bf.append(":");
  347.                             bf.append(versione);
  348.                         }
  349.                         accordi_list.add(bf.toString());
  350.                     }               
  351.                     isInUso=true;
  352.                 }
  353.                 risultato.close();
  354.                 stmt.close();

  356.             }

  358.             if(idSoggettoRegistro!=null){
  359.                 //controllo se referente di un accordo cooperazione
  360.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  361.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_COOPERAZIONE);
  362.                 sqlQueryObject.addSelectField("*");
  363.                 sqlQueryObject.addWhereCondition("id_referente = ?");
  364.                 queryString = sqlQueryObject.createSQLQuery();
  365.                 stmt = con.prepareStatement(queryString);
  366.                 stmt.setLong(1, idSoggetto);
  367.                 risultato = stmt.executeQuery();
  368.                 while (risultato.next()){
  369.                     String nomeAccordo = risultato.getString("nome");
  370.                     Integer versione = risultato.getInt("versione");
  371.                     if(normalizeObjectIds) {
  372.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idSoggettoRegistro.getTipo());
  373.                         IDAccordoCooperazione idAccordo = IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromValues(nomeAccordo, idSoggettoRegistro, versione); 
  374.                         accordi_coop_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoCooperazione(protocollo, idAccordo));
  375.                     }
  376.                     else {
  377.                         StringBuilder bf = new StringBuilder();
  378.                         bf.append(idSoggettoRegistro.toString());
  379.                         bf.append(":");
  380.                         bf.append(nomeAccordo);
  381.                         if(versione!=null){
  382.                             bf.append(":");
  383.                             bf.append(versione);
  384.                         }
  385.                         accordi_coop_list.add(bf.toString());
  386.                     }
  387.                     isInUso=true;
  388.                 }
  389.                 risultato.close();
  390.                 stmt.close();

  392.             }

  394.             if(idSoggettoRegistro!=null){

  396.                 //controllo se partecipante
  397.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  398.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_COOPERAZIONE_PARTECIPANTI);
  399.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_COOPERAZIONE);
  400.                 sqlQueryObject.addSelectField("*");
  401.                 sqlQueryObject.setANDLogicOperator(true);
  402.                 sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_COOPERAZIONE_PARTECIPANTI+".id_accordo_cooperazione = "+CostantiDB.ACCORDI_COOPERAZIONE+".id");
  403.                 sqlQueryObject.addWhereCondition("id_soggetto = ?");
  404.                 queryString = sqlQueryObject.createSQLQuery();
  405.                 stmt = con.prepareStatement(queryString);
  406.                 stmt.setLong(1, idSoggetto);
  407.                 risultato = stmt.executeQuery();
  408.                 while (risultato.next()){
  409.                     String nomeAccordo = risultato.getString("nome");
  410.                     Integer versione = risultato.getInt("versione");
  411.                     if(normalizeObjectIds) {
  412.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idSoggettoRegistro.getTipo());
  413.                         IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromValues(nomeAccordo, idSoggettoRegistro, versione); 
  414.                         partecipanti_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteComune(protocollo, idAccordo));
  415.                     }
  416.                     else {
  417.                         StringBuilder bf = new StringBuilder();
  418.                         bf.append(idSoggettoRegistro.toString());
  419.                         bf.append(":");
  420.                         bf.append(nomeAccordo);
  421.                         if(versione!=null){
  422.                             bf.append(":");
  423.                             bf.append(versione);
  424.                         }
  425.                         partecipanti_list.add(bf.toString());
  426.                     }
  427.                     isInUso=true;
  428.                 }
  429.                 risultato.close();
  430.                 stmt.close();

  432.             }
  433.             
  434.             if(idSoggettoRegistro!=null && mappingFruizionePD_list.isEmpty() && mappingErogazionePA_list.isEmpty()){
  435.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  436.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  437.                 sqlQueryObject.addSelectField("*");
  438.                 sqlQueryObject.addWhereCondition("id_soggetto = ?");
  439.                 queryString = sqlQueryObject.createSQLQuery();
  440.                 stmt = con.prepareStatement(queryString);
  441.                 stmt.setLong(1, idSoggetto);
  442.                 risultato = stmt.executeQuery();
  443.                 while (risultato.next()) {
  444.                     String nome_servizio = risultato.getString("nome_servizio");
  445.                     String tipo_servizio = risultato.getString("tipo_servizio");
  446.                     Integer versione_servizio = risultato.getInt("versione_servizio");
  447.                     if(normalizeObjectIds) {
  448.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idSoggettoRegistro.getTipo());
  449.                         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipo_servizio, nome_servizio, idSoggettoRegistro, versione_servizio);
  450.                         servizi_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, idServizio));
  451.                     }
  452.                     else {
  453.                         servizi_list.add(idSoggettoRegistro.toString()+
  454.                                 "_"+tipo_servizio + "/" + nome_servizio+"/"+versione_servizio);
  455.                     }
  456.                     isInUso = true;
  457.                 }
  458.                 risultato.close();
  459.                 stmt.close();
  460.             }
  461.             
  462.             if(idSoggettoRegistro!=null && mappingFruizionePD_list.isEmpty() && mappingErogazionePA_list.isEmpty()){

  464.                 // controllo che non sia fruitore di un servizio
  465.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  466.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  467.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  468.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  469.                 sqlQueryObject.addSelectField("tipo_servizio");
  470.                 sqlQueryObject.addSelectField("nome_servizio");
  471.                 sqlQueryObject.addSelectField("versione_servizio");
  472.                 sqlQueryObject.addSelectField("tipo_soggetto");
  473.                 sqlQueryObject.addSelectField("nome_soggetto");
  474.                 sqlQueryObject.setANDLogicOperator(true);
  475.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_servizio = "+CostantiDB.SERVIZI+".id");
  476.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  477.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_soggetto = ?");
  478.                 queryString = sqlQueryObject.createSQLQuery();
  479.                 stmt = con.prepareStatement(queryString);
  480.                 stmt.setLong(1, idSoggetto);
  481.                 risultato = stmt.executeQuery();
  482.                 while (risultato.next()) {
  483.                     String tipo_soggetto = risultato.getString("tipo_soggetto");
  484.                     String nome_soggetto = risultato.getString("nome_soggetto");

  486.                     String tipoServizio = risultato.getString("tipo_servizio");
  487.                     String nomeServizio = risultato.getString("nome_servizio");
  488.                     Integer versioneServizio = risultato.getInt("versione_servizio");
  489.                     
  490.                     if(normalizeObjectIds) {
  491.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idSoggettoRegistro.getTipo());
  492.                         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipoServizio, nomeServizio, new IDSoggetto(tipo_soggetto, nome_soggetto), versioneServizio);
  493.                         servizi_fruitori_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, idServizio));
  494.                     }
  495.                     else {
  496.                         servizi_fruitori_list.add(tipo_soggetto+"/"+nome_soggetto+
  497.                                 "_"+
  498.                                 tipoServizio+"/"+nomeServizio+"/"+versioneServizio);
  499.                     }
  500.                     isInUso = true;
  501.                 }
  502.                 risultato.close();
  503.                 stmt.close();

  505.             }
  506.             
  507.             
  508.             // Controllo che il soggetto non sia associato ad utenti
  509.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  510.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  511.             sqlQueryObject.addFromTable(CostantiDB.USERS_SOGGETTI);
  512.             sqlQueryObject.addSelectField("login");
  513.             sqlQueryObject.setANDLogicOperator(true);
  514.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SOGGETTI+".id_soggetto = ?");
  515.             sqlQueryObject.addWhereCondition(CostantiDB.USERS+".id = "+CostantiDB.USERS_SOGGETTI+".id_utente");
  516.             queryString = sqlQueryObject.createSQLQuery();
  517.             stmt = con.prepareStatement(queryString);
  518.             stmt.setLong(1, idSoggetto);
  519.             risultato = stmt.executeQuery();
  520.             while (risultato.next()) {
  521.                 utenti_list.add(risultato.getString("login"));
  522.                 isInUso = true;
  523.             }
  524.             risultato.close();
  525.             stmt.close();
  526.             
  527.             
  528.             
  529.             
  530.             // Controllo che il soggetto non sia associato a policy di controllo del traffico o allarmi
  531.             
  532.             int max = 2;
  533.             if(!CostantiDB.isAllarmiEnabled()) {
  534.                 max=1;
  535.             }
  536.             for (int i = 0; i < max; i++) {
  537.                 
  538.                 String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  539.                 String identificativo_column = "active_policy_id";
  540.                 String alias_column = "policy_alias";
  541.                 List<String> list = ct_list;
  542.                 String oggetto = "Policy";
  543.                 if(i==1) {
  544.                     tabella = CostantiDB.ALLARMI;
  545.                     identificativo_column = "nome";
  546.                     alias_column = "alias";
  547.                     list = allarme_list;
  548.                     oggetto = "Allarme";
  549.                 }
  550.             
  551.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  552.                 sqlQueryObject.addFromTable(tabella);
  553.                 sqlQueryObject.addSelectField(identificativo_column);
  554.                 sqlQueryObject.addSelectField(alias_column);
  555.                 sqlQueryObject.addSelectField("filtro_ruolo");
  556.                 sqlQueryObject.addSelectField("filtro_porta");
  557.                 sqlQueryObject.setANDLogicOperator(false); // OR
  558.                 sqlQueryObject.addWhereCondition(true, 
  559.                         tabella+".filtro_tipo_fruitore = ?", 
  560.                         tabella+".filtro_nome_fruitore = ?");
  561.                 sqlQueryObject.addWhereCondition(true, 
  562.                         tabella+".filtro_tipo_erogatore = ?", 
  563.                         tabella+".filtro_nome_erogatore = ?");
  564.                 sqlQueryObject.addOrderBy("filtro_ruolo");
  565.                 sqlQueryObject.addOrderBy("filtro_porta");
  566.                 queryString = sqlQueryObject.createSQLQuery();
  567.                 stmt = con.prepareStatement(queryString);
  568.                 int index = 1;
  569.                 stmt.setString(index++, tipoSoggetto);
  570.                 stmt.setString(index++, nomeSoggetto);
  571.                 stmt.setString(index++, tipoSoggetto);
  572.                 stmt.setString(index++, nomeSoggetto);
  573.                 risultato = stmt.executeQuery();
  574.                 while (risultato.next()) {
  575.                     
  576.                     String alias = risultato.getString(alias_column);
  577.                     if(alias== null || "".equals(alias)) {
  578.                         alias = risultato.getString(identificativo_column);
  579.                     }
  580.                     
  581.                     String nomePorta = risultato.getString("filtro_porta");
  582.                     String filtro_ruolo = risultato.getString("filtro_ruolo");
  583.                     if(nomePorta!=null) {
  584.                         String tipo = null;
  585.                         String label = null;
  586.                         if("delegata".equals(filtro_ruolo)) {
  587.                             try {
  588.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  589.                                 if(resultPorta.mapping) {
  590.                                     label = "Fruizione di Servizio "+ resultPorta.label;
  591.                                 }
  592.                             }catch(Exception e) {
  593.                                 tipo = "Outbound";
  594.                             }
  595.                         }
  596.                         else if("applicativa".equals(filtro_ruolo)) {
  597.                             try {
  598.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  599.                                 if(resultPorta.mapping) {
  600.                                     label = "Erogazione di Servizio "+ resultPorta.label;
  601.                                 }
  602.                             }catch(Exception e) {
  603.                                 tipo = "Inbound";
  604.                             }
  605.                         }
  606.                         else {
  607.                             tipo = filtro_ruolo;
  608.                         }
  609.                         if(label==null) {
  610.                             list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  611.                         }
  612.                         else {
  613.                             list.add(oggetto+" '"+alias+"' attiva nella "+label);
  614.                         }
  615.                     }
  616.                     else {
  617.                         list.add(oggetto+" '"+alias+"'");
  618.                     }
  619.     
  620.                     isInUso = true;
  621.                 }
  622.                 risultato.close();
  623.                 stmt.close();
  624.             }

  626.             
  627.             // controllo se in uso in porte applicative nell'autorizzazione
  628.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  629.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  630.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SOGGETTI);
  631.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  632.             sqlQueryObject.setANDLogicOperator(true);
  633.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SOGGETTI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  634.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SOGGETTI+".tipo_soggetto=?");
  635.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SOGGETTI+".nome_soggetto=?"); 
  636.             queryString = sqlQueryObject.createSQLQuery();
  637.             stmt = con.prepareStatement(queryString);
  638.             stmt.setString(1, tipoSoggetto);
  639.             stmt.setString(2, nomeSoggetto);
  640.             risultato = stmt.executeQuery();
  641.             while (risultato.next()) {
  642.                 String nome = risultato.getString("nome_porta");
  643.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  644.                 if(resultPorta.mapping) {
  645.                     autorizzazionePA_mapping_list.add(resultPorta.label);
  646.                 }
  647.                 else {
  648.                     autorizzazionePA_list.add(resultPorta.label);
  649.                 }
  650.                 isInUso = true;
  651.             }
  652.             risultato.close();
  653.             stmt.close();
  654.             
  655.             
  656.             if(verificaRuoli) {
  657.                 // Raccolgo prima i ruoli
  658.                 List<String> listRuoliSoggetti = new ArrayList<>();
  659.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  660.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  661.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI_RUOLI);
  662.                 sqlQueryObject.addFromTable(CostantiDB.RUOLI);
  663.                 sqlQueryObject.addSelectAliasField(CostantiDB.RUOLI,"nome","nomeRuolo");
  664.                 sqlQueryObject.setANDLogicOperator(true);
  665.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".id=?");
  666.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI_RUOLI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  667.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI_RUOLI+".id_ruolo="+CostantiDB.RUOLI+".id");
  668.                 queryString = sqlQueryObject.createSQLQuery();
  669.                 stmt = con.prepareStatement(queryString);
  670.                 stmt.setLong(1, idSoggetto);
  671.                 risultato = stmt.executeQuery();
  672.                 while (risultato.next()){
  673.                     String ruolo = risultato.getString("nomeRuolo");
  674.                     listRuoliSoggetti.add(ruolo);
  675.                 }
  676.                 risultato.close();
  677.                 stmt.close();
  678.                 
  679.                 if(!listRuoliSoggetti.isEmpty()) {
  680.                 
  681.                     boolean isInUsoRuoli = _checkSoggetto_ruoloInUsoInPorteApplicative(con, tipoDB, normalizeObjectIds,
  682.                             CostantiDB.PORTE_APPLICATIVE_RUOLI,
  683.                             listRuoliSoggetti,
  684.                             ruoliPA_mapping_list, ruoliPA_list,
  685.                             ruoliPA_mapping_list, ruoliPA_list);
  686.                     if(isInUsoRuoli) {
  687.                         isInUso = true;
  688.                     }

  690.                     boolean isInUsoRuoliToken = _checkSoggetto_ruoloInUsoInPorteApplicative(con, tipoDB, normalizeObjectIds,
  691.                             CostantiDB.PORTE_APPLICATIVE_TOKEN_RUOLI,
  692.                             listRuoliSoggetti,
  693.                             ruoliTokenPA_mapping_list, ruoliTokenPA_list,
  694.                             ruoliTokenPA_mapping_modi_list, ruoliTokenPA_modi_list);
  695.                     if(isInUsoRuoliToken) {
  696.                         isInUso = true;
  697.                     }
  698.                     
  699.                 }
  700.             }

  702.             
  703.             // controllo se in uso in porte applicative nella trasformazione
  704.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  705.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  706.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI);
  707.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI);
  708.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  709.             sqlQueryObject.setANDLogicOperator(true);
  710.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  711.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id = "+CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI+".id_trasformazione");
  712.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI+".tipo_soggetto=?");
  713.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI_SOGGETTI+".nome_soggetto=?");  
  714.             queryString = sqlQueryObject.createSQLQuery();
  715.             stmt = con.prepareStatement(queryString);
  716.             stmt.setString(1, tipoSoggetto);
  717.             stmt.setString(2, nomeSoggetto);
  718.             risultato = stmt.executeQuery();
  719.             while (risultato.next()) {
  720.                 String nome = risultato.getString("nome_porta");
  721.                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  722.                 if(resultPorta.mapping) {
  723.                     trasformazionePA_mapping_list.add(resultPorta.label);
  724.                 }
  725.                 else {
  726.                     trasformazionePA_list.add(resultPorta.label);
  727.                 }
  728.                 isInUso = true;
  729.             }
  730.             risultato.close();
  731.             stmt.close();
  732.             
  733.             // controllo se in uso nelle regole di cnonfigurazione del proxy pass
  734.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  735.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  736.             sqlQueryObject.addSelectField(CostantiDB.CONFIG_URL_REGOLE+".nome");
  737.             sqlQueryObject.setANDLogicOperator(true);
  738.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_URL_REGOLE+".tipo_soggetto=?");
  739.             sqlQueryObject.addWhereCondition(CostantiDB.CONFIG_URL_REGOLE+".nome_soggetto=?");  
  740.             queryString = sqlQueryObject.createSQLQuery();
  741.             stmt = con.prepareStatement(queryString);
  742.             stmt.setString(1, tipoSoggetto);
  743.             stmt.setString(2, nomeSoggetto);
  744.             risultato = stmt.executeQuery();
  745.             while (risultato.next()) {
  746.                 String nome = risultato.getString("nome");
  747.                 configurazioniProxyPass_list.add(nome);
  748.                 isInUso = true;
  749.             }
  750.             risultato.close();
  751.             stmt.close();
  752.             
  753.             
  754.             return isInUso;

  756.         } catch (Exception se) {
  757.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  758.         } finally {
  759.             // Chiudo statement and resultset
  760.             JDBCUtilities.closeResources(risultato, stmt);
  761.         }
  762.     }

  764.     private static boolean _checkSoggetto_ruoloInUsoInPorteApplicative(Connection con, String tipoDB, boolean normalizeObjectIds,
  765.             String nomeTabella,
  766.             List<String> listRuoliSoggetti,
  767.             List<String> ruoliPA_mapping_list, List<String> ruoliPA_list,
  768.             List<String> ruoliPA_mapping_modi_list, List<String> ruoliPA_modi_list) throws Exception {
  769.         boolean isInUso = false;
  770.         PreparedStatement stmt = null;
  771.         ResultSet risultato = null;
  772.         try {

  774.             List<String> distinctPorteApplicative = new ArrayList<>();
  775.             List<String> verificaPorteApplicativeAll = new ArrayList<>();
  776.             
  777.             for (String ruolo : listRuoliSoggetti) {
  778.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  779.                 sqlQueryObject.addFromTable(nomeTabella);
  780.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  781.                 sqlQueryObject.addSelectField("nome_porta");
  782.                 sqlQueryObject.addSelectField("ruoli_match");
  783.                 sqlQueryObject.setANDLogicOperator(true);
  784.                 sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  785.                 sqlQueryObject.addWhereCondition(nomeTabella+".ruolo=?");
  786.                 String queryString = sqlQueryObject.createSQLQuery();
  787.                 stmt = con.prepareStatement(queryString);
  788.                 stmt.setString(1, ruolo);
  789.                 risultato = stmt.executeQuery();
  790.                 while (risultato.next()){
  791.                     String nome = risultato.getString("nome_porta");
  792.                     String ruolo_match = risultato.getString("ruoli_match");
  793.                     if(RuoloTipoMatch.ANY.getValue().equals(ruolo_match)) {
  794.                         if(distinctPorteApplicative.contains(nome)) {
  795.                             continue;
  796.                         }
  797.                         else {
  798.                             distinctPorteApplicative.add(nome);
  799.                         }
  800.                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  801.                         if(resultPorta.mapping) {
  802.                             if(resultPorta.erogazioneModi)
  803.                                 ruoliPA_mapping_modi_list.add(resultPorta.label);
  804.                             else
  805.                                 ruoliPA_mapping_list.add(resultPorta.label);
  806.                         }
  807.                         else {
  808.                             if(resultPorta.erogazioneModi)
  809.                                 ruoliPA_modi_list.add(resultPorta.label);
  810.                             else
  811.                                 ruoliPA_list.add(resultPorta.label);
  812.                         }
  813.                         isInUso = true;
  814.                     }
  815.                     else {
  816.                         // devo verificare tutti i ruoli richiesti
  817.                         if(verificaPorteApplicativeAll.contains(nome)) {
  818.                             continue;
  819.                         }
  820.                         else {
  821.                             verificaPorteApplicativeAll.add(nome);
  822.                         }
  823.                     }
  824.                 }
  825.                 risultato.close();
  826.                 stmt.close();   
  827.             }
  828.             
  829.             // autorizzazione 'all'
  830.             if(!verificaPorteApplicativeAll.isEmpty()) {
  831.                 for (String nome : verificaPorteApplicativeAll) {
  832.                     
  833.                     // Raccolgo prima i ruoli della porta
  834.                     List<String> listRuoliPorta = new ArrayList<>();
  835.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  836.                     sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  837.                     sqlQueryObject.addFromTable(nomeTabella);
  838.                     sqlQueryObject.addSelectField("ruolo");
  839.                     sqlQueryObject.setANDLogicOperator(true);
  840.                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta=?");
  841.                     sqlQueryObject.addWhereCondition(nomeTabella+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  842.                     String queryString = sqlQueryObject.createSQLQuery();
  843.                     stmt = con.prepareStatement(queryString);
  844.                     stmt.setString(1, nome);
  845.                     risultato = stmt.executeQuery();
  846.                     while (risultato.next()){
  847.                         String ruolo = risultato.getString("ruolo");
  848.                         listRuoliPorta.add(ruolo);
  849.                     }
  850.                     risultato.close();
  851.                     stmt.close();
  852.                     
  853.                     if(!listRuoliPorta.isEmpty()) {
  854.                         boolean match = true;
  855.                         for (String ruoloPorta : listRuoliPorta) {
  856.                             if(!listRuoliSoggetti.contains(ruoloPorta)) {
  857.                                 match = false;
  858.                                 break;
  859.                             }
  860.                         }
  861.                         if(match) {
  862.                             if(distinctPorteApplicative.contains(nome)) {
  863.                                 continue;
  864.                             }
  865.                             else {
  866.                                 distinctPorteApplicative.add(nome);
  867.                             }
  868.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  869.                             if(resultPorta.mapping) {
  870.                                 if(resultPorta.erogazioneModi)
  871.                                     ruoliPA_mapping_modi_list.add(resultPorta.label);
  872.                                 else
  873.                                     ruoliPA_mapping_list.add(resultPorta.label);
  874.                             }
  875.                             else {
  876.                                 if(resultPorta.erogazioneModi)
  877.                                     ruoliPA_modi_list.add(resultPorta.label);
  878.                                 else
  879.                                     ruoliPA_list.add(resultPorta.label);
  880.                             }
  881.                             isInUso = true;
  882.                         }
  883.                     }
  884.                     
  885.                 }
  886.             }

  888.         } finally {
  889.             // Chiudo statement and resultset
  890.             try {
  891.                 if (risultato != null) {
  892.                     risultato.close();
  893.                 }
  894.             } catch (Exception e) {
  895.                 // ignore
  896.             }
  897.             try {
  898.                 if (stmt != null) {
  899.                     stmt.close();
  900.                 }
  901.             } catch (Exception e) {
  902.                 // ignore
  903.             }
  904.         }
  905.         return isInUso;
  906.     }
  907.     
  908.     protected static String toString(IDSoggetto idSoggetto, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, boolean normalizeObjectIds){
  909.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  910.         String labelSoggetto = idSoggetto.toString();
  911.         try {
  912.             if(normalizeObjectIds) {
  913.                 String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idSoggetto.getTipo());
  914.                 labelSoggetto = DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelSoggetto(protocollo, idSoggetto);
  915.             }
  916.         }catch(Exception e) {
  917.             // ignore
  918.         }
  919.         String msg = "Soggetto '"+labelSoggetto+ "' non eliminabile perch&egrave; :"+separator;
  920.         if(prefix==false){
  921.             msg = "";
  922.         }
  923.         String separatorCategorie = "";
  924.         if(whereIsInUso.size()>1) {
  925.             separatorCategorie = separator;
  926.         }
  927.         for (ErrorsHandlerCostant key : keys) {
  928.             List<String> messages = whereIsInUso.get(key);

  930.             if ( messages!=null && messages.size() > 0) {
  931.                 msg += separatorCategorie;
  932.             }
  933.             
  934.             switch (key) {
  935.             case IS_FRUITORE:
  936.                 if ( messages!=null && messages.size() > 0) {
  937.                     msg += "fruitore dei Servizi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  938.                 }
  939.                 break;
  940.             case IN_USO_IN_SERVIZI_APPLICATIVI:
  941.                 if ( messages!=null && messages.size() > 0 ) {
  942.                     msg += "utilizzato negli Applicativi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  943.                 }
  944.                 break;
  945.             case IN_USO_IN_SERVIZI:
  946.                 if ( messages!=null && messages.size() > 0) {
  947.                     msg += "erogatore dei Servizi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  948.                 }
  949.                 break;
  950.             case IN_USO_IN_PORTE_APPLICATIVE:
  951.                 if ( messages!=null && messages.size() > 0) {
  952.                     msg += "utilizzato nelle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  953.                 }
  954.                 break;
  955.             case IN_USO_IN_PORTE_DELEGATE:
  956.                 if ( messages!=null && messages.size() > 0) {
  957.                     msg += "utilizzato nelle Porte Outbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  958.                 }
  959.                 break;
  960.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  961.                 if ( messages!=null && messages.size() > 0) {
  962.                     msg += "utilizzato nelle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  963.                 }
  964.                 break;
  965.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  966.                 if ( messages!=null && messages.size() > 0) {
  967.                     msg += "utilizzato nelle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  968.                 }
  969.                 break;
  970.             case IS_REFERENTE:
  971.                 if ( messages!=null && messages.size() > 0 ) {
  972.                     msg += "referente di API: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  973.                 }
  974.                 break;
  975.             case IS_REFERENTE_COOPERAZIONE:
  976.                 if ( messages!=null && messages.size() > 0 ) {
  977.                     msg += "referente di Accordi di Cooperazione: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  978.                 }
  979.                 break;
  980.             case IS_PARTECIPANTE_COOPERAZIONE:
  981.                 if ( messages!=null && messages.size() > 0 ) {
  982.                     msg += "partecipante in Accordi di Cooperazione: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  983.                 }
  984.                 break;
  985.             case UTENTE:
  986.                 if ( messages!=null && messages.size() > 0 ) {
  987.                     msg += "associato ad Utenti: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  988.                 }
  989.                 break;
  990.             case CONTROLLO_TRAFFICO:
  991.                 if ( messages!=null && messages.size() > 0 ) {
  992.                     msg += "utilizzato in policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  993.                 }
  994.                 break;
  995.             case ALLARMI:
  996.                 if ( messages!=null && messages.size() > 0 ) {
  997.                     msg += "utilizzato in Allarmi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  998.                 }
  999.                 break;
  1000.             case AUTORIZZAZIONE_MAPPING:
  1001.                 if ( messages!=null && messages.size() > 0) {
  1002.                     msg += "utilizzato nel Controllo degli Accessi (Soggetti Autenticati) delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1003.                 }
  1004.                 break;
  1005.             case AUTORIZZAZIONE:
  1006.                 if ( messages!=null && messages.size() > 0) {
  1007.                     msg += "utilizzato nelle Porte Inbound (Controllo degli Accessi - Soggetti Autenticati): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1008.                 }
  1009.                 break;
  1010.             case RUOLI_MAPPING:
  1011.                 if ( messages!=null && messages.size() > 0) {
  1012.                     msg += "compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1013.                 }
  1014.                 break;
  1015.             case RUOLI:
  1016.                 if ( messages!=null && messages.size() > 0) {
  1017.                     msg += "compatibile con l'Autorizzazione Trasporto per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1018.                 }
  1019.                 break;
  1020.             case RUOLI_TOKEN_MAPPING_PA:
  1021.                 if ( messages!=null && messages.size() > 0) {
  1022.                     msg += "compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1023.                 }
  1024.                 break;
  1025.             case RUOLI_TOKEN_PA:
  1026.                 if ( messages!=null && messages.size() > 0) {
  1027.                     msg += "compatibile con l'Autorizzazione Token per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1028.                 }
  1029.                 break;
  1030.             case RUOLI_TOKEN_MAPPING_PA_MODI:
  1031.                 if ( messages!=null && messages.size() > 0) {
  1032.                     msg += "compatibile con l'Autorizzazione Messaggio per Ruoli indicata nel Controllo degli Accessi delle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1033.                 }
  1034.                 break;
  1035.             case RUOLI_TOKEN_PA_MODI:
  1036.                 if ( messages!=null && messages.size() > 0) {
  1037.                     msg += "compatibile con l'Autorizzazione Messaggio per Ruoli indicata nel Controllo degli Accessi delle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1038.                 }
  1039.                 break;
  1040.             case TRASFORMAZIONE_MAPPING_PA:
  1041.                 if ( messages!=null && messages.size() > 0) {
  1042.                     msg += "utilizzato nel criterio di applicabilità della Trasformazione (Soggetti) per le Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1043.                 }
  1044.                 break;
  1045.             case TRASFORMAZIONE_PA:
  1046.                 if ( messages!=null && messages.size() > 0) {
  1047.                     msg += "utilizzato nelle Porte Inbound (Criterio di applicabilità della Trasformazione - Soggetti): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1048.                 }
  1049.                 break;
  1050.             case CONFIGURAZIONE_REGOLE_PROXY_PASS:
  1051.                 if ( messages!=null && messages.size() > 0) {
  1052.                     msg += "utilizzato nelle Regole di Proxy Pass: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  1053.                 }
  1054.                 break;
  1055.             default:
  1056.                 msg += "utilizzato in oggetto non codificato ("+key+")"+separator;
  1057.                 break;
  1058.             }

  1060.         }// chiudo for

  1062.         return msg;
  1063.     }
  1064.     
  1065. }
Created with JaCoCo 0.8.8.202204050719