DBOggettiInUsoUtils_gruppi.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.IDAccordo;
  35. import org.openspcoop2.core.id.IDGruppo;
  36. import org.openspcoop2.core.id.IDSoggetto;
  37. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  38. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  39. import org.openspcoop2.utils.UtilsException;
  40. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  41. import org.openspcoop2.utils.sql.ISQLQueryObject;
  42. import org.openspcoop2.utils.sql.SQLObjectFactory;

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

  54.     // Lascio i metodi se servissero in futuro
  55.     protected static boolean isGruppoConfigInUso(Connection con, String tipoDB, IDGruppo idGruppo, Map<ErrorsHandlerCostant, 
  56.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  57.         return _isGruppoInUso(con,tipoDB,idGruppo,false,true,whereIsInUso,normalizeObjectIds);
  58.     }
  59.     protected static boolean isGruppoRegistryInUso(Connection con, String tipoDB, IDGruppo idGruppo, Map<ErrorsHandlerCostant, 
  60.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  61.         return _isGruppoInUso(con,tipoDB,idGruppo,true,false,whereIsInUso,normalizeObjectIds);
  62.     }
  63.     protected static boolean isGruppoInUso(Connection con, String tipoDB, IDGruppo idGruppo, Map<ErrorsHandlerCostant, 
  64.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  65.         return _isGruppoInUso(con,tipoDB,idGruppo,true,true,whereIsInUso,normalizeObjectIds);
  66.     }
  67.     private static boolean _isGruppoInUso(Connection con, String tipoDB, IDGruppo idGruppo, boolean registry, boolean config, Map<ErrorsHandlerCostant, 
  68.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  69.         String nomeMetodo = "_isGruppoInUso";

  71.         PreparedStatement stmt = null;
  72.         ResultSet risultato = null;
  73.         PreparedStatement stmt2 = null;
  74.         ResultSet risultato2 = null;
  75.         String queryString;

  77.         try {

  79.             long idG = DBUtils.getIdGruppo(idGruppo, con, tipoDB);

  81.             boolean isInUso = false;

  83.             List<String> accordi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_ACCORDI);
  84.             List<String> ct_list = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  85.             List<String> allarme_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI); 

  87.             if (accordi_list == null) {
  88.                 accordi_list = new ArrayList<>();
  89.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_ACCORDI, accordi_list);
  90.             }
  91.             if (ct_list == null) {
  92.                 ct_list = new ArrayList<>();
  93.                 whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ct_list);
  94.             }
  95.             if (allarme_list == null) {
  96.                 allarme_list = new ArrayList<>();
  97.                 whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarme_list);
  98.             }


  101.             // Controllo che il gruppo non sia in uso negli accordi
  102.             if(registry){

  104.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  105.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI_GRUPPI);
  106.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  107.                 sqlQueryObject.addSelectField("*");
  108.                 sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_GRUPPI+".id_gruppo = ?");
  109.                 sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_GRUPPI+".id_accordo = "+CostantiDB.ACCORDI+".id");
  110.                 sqlQueryObject.setANDLogicOperator(true);
  111.                 queryString = sqlQueryObject.createSQLQuery();
  112.                 stmt = con.prepareStatement(queryString);
  113.                 stmt.setLong(1, idG);
  114.                 risultato = stmt.executeQuery();
  115.                 while (risultato.next()){
  116.                     isInUso=true;

  118.                     String nomeAccordo = risultato.getString("nome");
  119.                     int versione = risultato.getInt("versione");
  120.                     long idReferente = risultato.getLong("id_referente");
  121.                     IDSoggetto idReferenteObject = null;

  123.                     if(idReferente>0){

  125.                         ISQLQueryObject sqlQueryObjectReferente = SQLObjectFactory.createSQLQueryObject(tipoDB);
  126.                         sqlQueryObjectReferente.addFromTable(CostantiDB.SOGGETTI);
  127.                         sqlQueryObjectReferente.addSelectField("*");
  128.                         sqlQueryObjectReferente.addWhereCondition("id=?");
  129.                         sqlQueryObjectReferente.setANDLogicOperator(true);
  130.                         String queryStringReferente = sqlQueryObjectReferente.createSQLQuery();
  131.                         stmt2 = con.prepareStatement(queryStringReferente);
  132.                         stmt2.setLong(1, idReferente);
  133.                         risultato2 = stmt2.executeQuery();
  134.                         if(risultato2.next()){
  135.                             idReferenteObject = new IDSoggetto();
  136.                             idReferenteObject.setTipo(risultato2.getString("tipo_soggetto"));
  137.                             idReferenteObject.setNome(risultato2.getString("nome_soggetto"));
  138.                         }
  139.                         risultato2.close(); risultato2=null;
  140.                         stmt2.close(); stmt2=null;

  142.                     }

  144.                     if(normalizeObjectIds && idReferenteObject!=null) {
  145.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idReferenteObject.getTipo());
  146.                         IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromValues(nomeAccordo, idReferenteObject, versione); 
  147.                         accordi_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteComune(protocollo, idAccordo));
  148.                     }
  149.                     else {

  151.                         StringBuilder bf = new StringBuilder();

  153.                         bf.append(idReferenteObject!=null ? idReferenteObject.getTipo() : "?");
  154.                         bf.append("/");
  155.                         bf.append(idReferenteObject!=null ? idReferenteObject.getNome() : "?");
  156.                         bf.append(":");

  158.                         bf.append(nomeAccordo);

  160.                         if(idReferente>0){
  161.                             bf.append(":");
  162.                             bf.append(versione);
  163.                         }

  165.                         accordi_list.add(bf.toString());
  166.                     }

  168.                 }
  169.                 risultato.close();
  170.                 stmt.close();
  171.             }

  173.             // Controllo che il soggetto non sia associato a policy di controllo del traffico o allarmi
  174.             if(config){

  176.                 int max = 2;
  177.                 if(!CostantiDB.isAllarmiEnabled()) {
  178.                     max=1;
  179.                 }

  181.                 for (int i = 0; i < max; i++) {

  183.                     String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  184.                     String identificativo_column = "active_policy_id";
  185.                     String alias_column = "policy_alias";
  186.                     List<String> list = ct_list;
  187.                     String oggetto = "Policy";
  188.                     if(i==1) {
  189.                         tabella = CostantiDB.ALLARMI;
  190.                         identificativo_column = "nome";
  191.                         alias_column = "alias";
  192.                         list = allarme_list;
  193.                         oggetto = "Allarme";
  194.                     }

  196.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  197.                     sqlQueryObject.addFromTable(tabella);
  198.                     sqlQueryObject.addSelectField(identificativo_column);
  199.                     sqlQueryObject.addSelectField(alias_column);
  200.                     sqlQueryObject.addSelectField("filtro_ruolo");
  201.                     sqlQueryObject.addSelectField("filtro_porta");
  202.                     sqlQueryObject.setANDLogicOperator(false); // OR
  203.                     sqlQueryObject.addWhereCondition(true, 
  204.                             tabella+".filtro_tag = ?");
  205.                     queryString = sqlQueryObject.createSQLQuery();
  206.                     sqlQueryObject.addOrderBy("filtro_ruolo");
  207.                     sqlQueryObject.addOrderBy("filtro_porta");
  208.                     stmt = con.prepareStatement(queryString);
  209.                     int index = 1;
  210.                     stmt.setString(index++, idGruppo.getNome());
  211.                     risultato = stmt.executeQuery();
  212.                     while (risultato.next()) {

  214.                         String alias = risultato.getString(alias_column);
  215.                         if(alias== null || "".equals(alias)) {
  216.                             alias = risultato.getString(identificativo_column);
  217.                         }

  219.                         String nomePorta = risultato.getString("filtro_porta");
  220.                         String filtro_ruolo = risultato.getString("filtro_ruolo");
  221.                         if(nomePorta!=null) {
  222.                             String tipo = null;
  223.                             String label = null;
  224.                             if("delegata".equals(filtro_ruolo)) {
  225.                                 try {
  226.                                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  227.                                     if(resultPorta.mapping) {
  228.                                         label = "Fruizione di Servizio "+ resultPorta.label;
  229.                                     }
  230.                                 }catch(Exception e) {
  231.                                     tipo = "Outbound";
  232.                                 }
  233.                             }
  234.                             else if("applicativa".equals(filtro_ruolo)) {
  235.                                 try {
  236.                                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  237.                                     if(resultPorta.mapping) {
  238.                                         label = "Erogazione di Servizio "+ resultPorta.label;
  239.                                     }
  240.                                 }catch(Exception e) {
  241.                                     tipo = "Inbound";
  242.                                 }
  243.                             }
  244.                             else {
  245.                                 tipo = filtro_ruolo;
  246.                             }
  247.                             if(label==null) {
  248.                                 list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  249.                             }
  250.                             else {
  251.                                 list.add(oggetto+" '"+alias+"' attiva nella "+label);
  252.                             }
  253.                         }
  254.                         else {
  255.                             list.add(oggetto+" '"+alias+"'");
  256.                         }

  258.                         isInUso = true;
  259.                     }
  260.                     risultato.close();
  261.                     stmt.close();

  263.                 }
  264.             }

  266.             return isInUso;

  268.         } catch (Exception se) {
  269.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  270.         } finally {
  271.             // Chiudo statement and resultset
  272.             JDBCUtilities.closeResources(risultato2, stmt2);
  273.             JDBCUtilities.closeResources(risultato, stmt);
  274.         }
  275.     }


  278.     protected static String toString(IDGruppo idGruppo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  279.         return toString(idGruppo, whereIsInUso, prefix, separator," non eliminabile perch&egrave; :");
  280.     }
  281.     protected static String toString(IDGruppo idGruppo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  282.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  283.         String msg = "Gruppo '"+idGruppo.getNome()+"'" + intestazione+separator;
  284.         if(prefix==false){
  285.             msg = "";
  286.         }
  287.         String separatorCategorie = "";
  288.         if(whereIsInUso.size()>1) {
  289.             separatorCategorie = separator;
  290.         }
  291.         for (ErrorsHandlerCostant key : keys) {
  292.             List<String> messages = whereIsInUso.get(key);

  294.             if ( messages!=null && messages.size() > 0) {
  295.                 msg += separatorCategorie;
  296.             }

  298.             switch (key) {
  299.             case IN_USO_IN_ACCORDI:
  300.                 if ( messages!=null && messages.size() > 0 ) {
  301.                     msg += "associato all'API: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  302.                 }
  303.                 break;
  304.             case CONTROLLO_TRAFFICO:
  305.                 if ( messages!=null && messages.size() > 0 ) {
  306.                     msg += "utilizzato in Policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  307.                 }
  308.                 break;
  309.             case ALLARMI:
  310.                 if ( messages!=null && messages.size() > 0 ) {
  311.                     msg += "utilizzato in Allarmi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  312.                 }
  313.                 break;
  314.             default:
  315.                 msg += "utilizzato in oggetto non codificato ("+key+")"+separator;
  316.                 break;
  317.             }

  319.         }// chiudo for

  321.         return msg;
  322.     }

  324. }
Created with JaCoCo 0.8.8.202204050719