DBOggettiInUsoUtils_scope.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.ErrorsHandlerCostant;
  32. import org.openspcoop2.core.constants.CostantiDB;
  33. import org.openspcoop2.core.id.IDScope;
  34. import org.openspcoop2.utils.UtilsException;
  35. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  36. import org.openspcoop2.utils.sql.ISQLQueryObject;
  37. import org.openspcoop2.utils.sql.SQLObjectFactory;

  39. /**
  40.  * DBOggettiInUsoUtils_scope
  41.  * 
  42.  * @author Andrea Poli (apoli@link.it)
  43.  * @author $Author$
  44.  * @version $Rev$, $Date$
  45.  * 
  46.  */
  47. public class DBOggettiInUsoUtils_scope {

  49.     protected static boolean isScopeConfigInUso(Connection con, String tipoDB, IDScope idScope, Map<ErrorsHandlerCostant, 
  50.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  51.         return _isScopeInUso(con,tipoDB,idScope,false,true,whereIsInUso,normalizeObjectIds);
  52.     }
  53. //  protected static boolean isScopeRegistryInUso(Connection con, String tipoDB, IDScope idScope, Map<ErrorsHandlerCostant, 
  54. //          List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  55. //      return _isScopeInUso(con,tipoDB,idScope,true,false,whereIsInUso,normalizeObjectIds);
  56. //  }
  57.     protected static boolean isScopeInUso(Connection con, String tipoDB, IDScope idScope, Map<ErrorsHandlerCostant, 
  58.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  59.         return _isScopeInUso(con,tipoDB,idScope,true,true,whereIsInUso,normalizeObjectIds);
  60.     }
  61.     private static boolean _isScopeInUso(Connection con, String tipoDB, IDScope idScope, boolean registry, boolean config, 
  62.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  63.         String nomeMetodo = "_isScopeInUso";

  65.         PreparedStatement stmt = null;
  66.         ResultSet risultato = null;
  67.         String queryString;

  69.         try {

  71.             //long idS = DBUtils.getIdScope(idScope, con, tipoDB);
  72.             
  73.             boolean isInUso = false;
  74.             
  75.             List<String> porte_applicative_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  76.             List<String> porte_delegate_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE);
  77.             List<String> mappingErogazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  78.             List<String> mappingFruizionePD_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD);
  79.             
  80.             if (porte_applicative_list == null) {
  81.                 porte_applicative_list = new ArrayList<>();
  82.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porte_applicative_list);
  83.             }
  84.             if (porte_delegate_list == null) {
  85.                 porte_delegate_list = new ArrayList<>();
  86.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE, porte_delegate_list);
  87.             }
  88.             if (mappingErogazionePA_list == null) {
  89.                 mappingErogazionePA_list = new ArrayList<>();
  90.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePA_list);
  91.             }
  92.             if (mappingFruizionePD_list == null) {
  93.                 mappingFruizionePD_list = new ArrayList<>();
  94.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePD_list);
  95.             }
  96.             

  98.             // Controllo che il scope non sia in uso nelle porte applicative
  99.             if(config){
  100.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  101.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SCOPE);
  102.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  103.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  104.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  105.                 sqlQueryObject.setANDLogicOperator(true);
  106.                 sqlQueryObject.setSelectDistinct(true);
  107.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SCOPE+".scope = ?");
  108.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SCOPE+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  109.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  110.                 queryString = sqlQueryObject.createSQLQuery();
  111.                 stmt = con.prepareStatement(queryString);
  112.                 stmt.setString(1, idScope.getNome());
  113.                 risultato = stmt.executeQuery();
  114.                 while (risultato.next()) {
  115.                     String nome = risultato.getString("nome_porta");
  116.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  117.                     if(resultPorta.mapping) {
  118.                         mappingErogazionePA_list.add(resultPorta.label);
  119.                     }
  120.                     else {
  121.                         porte_applicative_list.add(resultPorta.label);
  122.                     }
  123.                     isInUso = true;
  124.                 }
  125.                 risultato.close();
  126.                 stmt.close();
  127.             }
  128.             
  129.             // Controllo che il scope non sia in uso nelle porte applicative
  130.             if(config){
  131.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  132.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_SCOPE);
  133.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  134.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  135.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  136.                 sqlQueryObject.setANDLogicOperator(true);
  137.                 sqlQueryObject.setSelectDistinct(true);
  138.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_SCOPE+".scope = ?");
  139.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_SCOPE+".id_porta = "+CostantiDB.PORTE_DELEGATE+".id");
  140.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  141.                 queryString = sqlQueryObject.createSQLQuery();
  142.                 stmt = con.prepareStatement(queryString);
  143.                 stmt.setString(1, idScope.getNome());
  144.                 risultato = stmt.executeQuery();
  145.                 while (risultato.next()) {
  146.                     String nome = risultato.getString("nome_porta");
  147.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  148.                     if(resultPorta.mapping) {
  149.                         mappingFruizionePD_list.add(resultPorta.label);
  150.                     }
  151.                     else {
  152.                         porte_delegate_list.add(resultPorta.label);
  153.                     }
  154.                     isInUso = true;
  155.                 }
  156.                 risultato.close();
  157.                 stmt.close();
  158.             }
  159.             
  160.             return isInUso;

  162.         } catch (Exception se) {
  163.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  164.         } finally {
  165.             // Chiudo statement and resultset
  166.             JDBCUtilities.closeResources(risultato, stmt);
  167.         }
  168.     }


  171.     protected static String toString(IDScope idScope, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  172.         return toString(idScope, whereIsInUso, prefix, separator," non eliminabile perch&egrave; :");
  173.     }
  174.     protected static String toString(IDScope idScope, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  175.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  176.         String msg = "Scope '"+ idScope.getNome() + "'" + intestazione+separator;
  177.         if(prefix==false){
  178.             msg = "";
  179.         }
  180.         String separatorCategorie = "";
  181.         if(whereIsInUso.size()>1) {
  182.             separatorCategorie = separator;
  183.         }
  184.         for (ErrorsHandlerCostant key : keys) {
  185.             List<String> messages = whereIsInUso.get(key);

  187.             if ( messages!=null && messages.size() > 0) {
  188.                 msg += separatorCategorie;
  189.             }
  190.             
  191.             switch (key) {

  193.             case IN_USO_IN_PORTE_APPLICATIVE:
  194.                 if ( messages!=null && messages.size() > 0) {
  195.                     msg += "utilizzato nelle Porte Inbound (Controllo Accessi - Autorizzazione Token): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  196.                 }
  197.                 break;
  198.             case IN_USO_IN_PORTE_DELEGATE:
  199.                 if ( messages!=null && messages.size() > 0) {
  200.                     msg += "utilizzato nelle Porte Outbound (Controllo Accessi - Autorizzazione Token): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  201.                 }
  202.                 break;
  203.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  204.                 if ( messages!=null && messages.size() > 0) {
  205.                     msg += "utilizzato nelle Erogazioni (Controllo Accessi - Autorizzazione Token): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  206.                 }
  207.                 break;
  208.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  209.                 if ( messages!=null && messages.size() > 0) {
  210.                     msg += "utilizzato nelle Fruizioni (Controllo Accessi - Autorizzazione Token): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  211.                 }
  212.                 break;
  213.                 
  214.             default:
  215.                 msg += "utilizzato in oggetto non codificato ("+key+")"+separator;
  216.                 break;
  217.             }

  219.         }// chiudo for

  221.         return msg;
  222.     }
  223.     
  224. }
Created with JaCoCo 0.8.8.202204050719