DBOggettiInUsoUtils_canali.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.config.CanaleConfigurazione;
  33. import org.openspcoop2.core.constants.CostantiDB;
  34. import org.openspcoop2.core.id.IDAccordo;
  35. import org.openspcoop2.core.id.IDSoggetto;
  36. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  37. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  38. import org.openspcoop2.utils.UtilsException;
  39. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  40. import org.openspcoop2.utils.sql.ISQLQueryObject;
  41. import org.openspcoop2.utils.sql.LikeConfig;
  42. import org.openspcoop2.utils.sql.SQLObjectFactory;

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

  54.     protected static boolean isCanaleInUsoRegistro(Connection con, String tipoDB, CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  55.         return isCanaleInUso(con, tipoDB, canale, whereIsInUso, normalizeObjectIds, true, true, false);
  56.     }
  57.     protected static boolean isCanaleInUso(Connection con, String tipoDB, CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  58.         return isCanaleInUso(con, tipoDB, canale, whereIsInUso, normalizeObjectIds, true, true, true);
  59.     }
  60.     protected static boolean isCanaleInUso(Connection con, String tipoDB, CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds, boolean registry, boolean config, boolean nodi) throws UtilsException {
  61.         String nomeMetodo = "_isCanaleInUso";

  63.         PreparedStatement stmt = null;
  64.         ResultSet risultato = null;
  65.         PreparedStatement stmt2 = null;
  66.         ResultSet risultato2 = null;
  67.         String queryString;

  69.         try {
  70.             String nomeCanale = canale.getNome();
  71.             
  72.             boolean isInUso = false;
  73.             
  74.             List<String> accordi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_ACCORDI);
  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.             List<String> nodi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_CANALE_NODO);
  80.             
  81.             if (accordi_list == null) {
  82.                 accordi_list = new ArrayList<>();
  83.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_ACCORDI, accordi_list);
  84.             }
  85.             if (porte_applicative_list == null) {
  86.                 porte_applicative_list = new ArrayList<>();
  87.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porte_applicative_list);
  88.             }
  89.             if (porte_delegate_list == null) {
  90.                 porte_delegate_list = new ArrayList<>();
  91.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE, porte_delegate_list);
  92.             }
  93.             if (mappingErogazionePA_list == null) {
  94.                 mappingErogazionePA_list = new ArrayList<>();
  95.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePA_list);
  96.             }
  97.             if (mappingFruizionePD_list == null) {
  98.                 mappingFruizionePD_list = new ArrayList<>();
  99.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePD_list);
  100.             }
  101.             if (nodi_list == null) {
  102.                 nodi_list = new ArrayList<>();
  103.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_CANALE_NODO, nodi_list);
  104.             }
  105.             
  106.             // Controllo che il gruppo non sia in uso negli accordi
  107.             if(registry) {
  108.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  109.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  110.                 sqlQueryObject.addSelectField("*");
  111.                 sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI+".canale = ?");
  112.                 sqlQueryObject.setANDLogicOperator(true);
  113.                 queryString = sqlQueryObject.createSQLQuery();
  114.                 stmt = con.prepareStatement(queryString);
  115.                 stmt.setString(1, nomeCanale);
  116.                 risultato = stmt.executeQuery();
  117.                 while (risultato.next()){
  118.                     isInUso=true;
  119.                     
  120.                     String nomeAccordo = risultato.getString("nome");
  121.                     int versione = risultato.getInt("versione");
  122.                     long idReferente = risultato.getLong("id_referente");
  123.                     IDSoggetto idReferenteObject = null;
  124.                     
  125.                     if(idReferente>0){
  126.     
  127.                         ISQLQueryObject sqlQueryObjectReferente = SQLObjectFactory.createSQLQueryObject(tipoDB);
  128.                         sqlQueryObjectReferente.addFromTable(CostantiDB.SOGGETTI);
  129.                         sqlQueryObjectReferente.addSelectField("*");
  130.                         sqlQueryObjectReferente.addWhereCondition("id=?");
  131.                         sqlQueryObjectReferente.setANDLogicOperator(true);
  132.                         String queryStringReferente = sqlQueryObjectReferente.createSQLQuery();
  133.                         stmt2 = con.prepareStatement(queryStringReferente);
  134.                         stmt2.setLong(1, idReferente);
  135.                         risultato2 = stmt2.executeQuery();
  136.                         if(risultato2.next()){
  137.                             idReferenteObject = new IDSoggetto();
  138.                             idReferenteObject.setTipo(risultato2.getString("tipo_soggetto"));
  139.                             idReferenteObject.setNome(risultato2.getString("nome_soggetto"));
  140.                         }
  141.                         risultato2.close(); risultato2=null;
  142.                         stmt2.close(); stmt2=null;
  143.     
  144.                     }
  145.                     
  146.                     if(normalizeObjectIds && idReferenteObject!=null) {
  147.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idReferenteObject.getTipo());
  148.                         IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromValues(nomeAccordo, idReferenteObject, versione); 
  149.                         accordi_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteComune(protocollo, idAccordo));
  150.                     }
  151.                     else {
  152.     
  153.                         StringBuilder bf = new StringBuilder();
  154.     
  155.                         bf.append(idReferenteObject!=null ? idReferenteObject.getTipo() : "?");
  156.                         bf.append("/");
  157.                         bf.append(idReferenteObject!=null ? idReferenteObject.getNome() : "?");
  158.                         bf.append(":");
  159.                         
  160.                         bf.append(nomeAccordo);
  161.         
  162.                         if(idReferente>0){
  163.                             bf.append(":");
  164.                             bf.append(versione);
  165.                         }
  166.         
  167.                         accordi_list.add(bf.toString());
  168.                     }
  169.                     
  170.                 }
  171.                 risultato.close();
  172.                 stmt.close();
  173.             }
  174.             
  175.             // Controllo che il canale non sia in uso nelle porte applicative
  176.             if(config){
  177.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  178.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  179.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  180.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  181.                 sqlQueryObject.setANDLogicOperator(true);
  182.                 sqlQueryObject.setSelectDistinct(true);
  183.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".canale = ?");
  184.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  185.                 queryString = sqlQueryObject.createSQLQuery();
  186.                 stmt = con.prepareStatement(queryString);
  187.                 stmt.setString(1, nomeCanale);
  188.                 risultato = stmt.executeQuery();
  189.                 while (risultato.next()) {
  190.                     String nome = risultato.getString("nome_porta");
  191.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  192.                     if(resultPorta.mapping) {
  193.                         mappingErogazionePA_list.add(resultPorta.label);
  194.                     }
  195.                     else {
  196.                         porte_applicative_list.add(resultPorta.label);
  197.                     }
  198.                     isInUso = true;
  199.                 }
  200.                 risultato.close();
  201.                 stmt.close();
  202.             }
  203.             
  204.             // Controllo che il canale non sia in uso nelle porte applicative
  205.             if(config){
  206.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  207.                 sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  208.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  209.                 sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  210.                 sqlQueryObject.setANDLogicOperator(true);
  211.                 sqlQueryObject.setSelectDistinct(true);
  212.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".canale = ?");
  213.                 sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  214.                 queryString = sqlQueryObject.createSQLQuery();
  215.                 stmt = con.prepareStatement(queryString);
  216.                 stmt.setString(1, nomeCanale);
  217.                 risultato = stmt.executeQuery();
  218.                 while (risultato.next()) {
  219.                     String nome = risultato.getString("nome_porta");
  220.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  221.                     if(resultPorta.mapping) {
  222.                         mappingFruizionePD_list.add(resultPorta.label);
  223.                     }
  224.                     else {
  225.                         porte_delegate_list.add(resultPorta.label);
  226.                     }
  227.                     isInUso = true;
  228.                 }
  229.                 risultato.close();
  230.                 stmt.close();
  231.             }
  232.             
  233.             // Controllo che il canale non sia in uso in un nodo
  234.             if(nodi){
  235.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  236.                 sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CANALI_NODI);
  237.                 sqlQueryObject.addSelectField(CostantiDB.CONFIGURAZIONE_CANALI_NODI+".nome");
  238.                 sqlQueryObject.setANDLogicOperator(false);
  239.                 sqlQueryObject.setSelectDistinct(true);
  240.                 // condizione di controllo
  241.                 // (canali == 'NOME') OR (canali like 'CANALE,%') OR (canali like '%,CANALE') OR (canali like '%,CANALE,%')
  242.                 sqlQueryObject.addWhereCondition(CostantiDB.CONFIGURAZIONE_CANALI_NODI+".canali = ?");
  243.                 // fix: devo generare io il % e non farlo fare a sql query object poiche' mi serve lo start e l'end
  244.                 sqlQueryObject.addWhereLikeCondition(CostantiDB.CONFIGURAZIONE_CANALI_NODI+".canali", nomeCanale+",", LikeConfig.startsWith(false));
  245.                 sqlQueryObject.addWhereLikeCondition(CostantiDB.CONFIGURAZIONE_CANALI_NODI+".canali", ","+nomeCanale, LikeConfig.endsWith(false));
  246.                 sqlQueryObject.addWhereLikeCondition(CostantiDB.CONFIGURAZIONE_CANALI_NODI+".canali", ","+nomeCanale+",", true , false);
  247.                 queryString = sqlQueryObject.createSQLQuery(); 
  248.                 stmt = con.prepareStatement(queryString);
  249.                 stmt.setString(1, nomeCanale);
  250.                 risultato = stmt.executeQuery();
  251.                 while (risultato.next()) {
  252.                     String nome = risultato.getString("nome");
  253.                     nodi_list.add(nome);
  254.                     isInUso = true;
  255.                 }
  256.                 risultato.close();
  257.                 stmt.close();
  258.             }

  260.             return isInUso;

  262.         } catch (Exception se) {
  263.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  264.         } finally {
  265.             // Chiudo statement and resultset
  266.             JDBCUtilities.closeResources(risultato2, stmt2);
  267.             JDBCUtilities.closeResources(risultato, stmt);
  268.         }
  269.     }

  271.     protected static String toString(CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  272.         return toString(canale, whereIsInUso, prefix, separator," non eliminabile perch&egrave; :");
  273.     }
  274.     protected static String toString(CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  275.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  276.         String msg = "Canale '"+canale.getNome()+"'" + intestazione+separator;
  277.         if(prefix==false){
  278.             msg = "";
  279.         }
  280.         String separatorCategorie = "";
  281.         if(whereIsInUso.size()>1) {
  282.             separatorCategorie = separator;
  283.         }
  284.         for (ErrorsHandlerCostant key : keys) {
  285.             List<String> messages = whereIsInUso.get(key);

  287.             if ( messages!=null && messages.size() > 0) {
  288.                 msg += separatorCategorie;
  289.             }
  290.             
  291.             switch (key) {
  292.             case IN_USO_IN_ACCORDI:
  293.                 if ( messages!=null && messages.size() > 0 ) {
  294.                     msg += "associato all'API: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  295.                 }
  296.                 break;
  297.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  298.                 if ( messages!=null && messages.size() > 0) {
  299.                     msg += "utilizzato nelle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  300.                 }
  301.                 break;
  302.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  303.                 if ( messages!=null && messages.size() > 0) {
  304.                     msg += "utilizzato nelle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  305.                 }
  306.                 break;
  307.             case IN_USO_IN_PORTE_DELEGATE:
  308.                 if ( messages!=null && messages.size() > 0 ) {
  309.                     msg += "in uso in Porte Delegate: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  310.                 }
  311.                 break;
  312.             case IN_USO_IN_PORTE_APPLICATIVE:
  313.                 if ( messages!=null && messages.size() > 0 ) {
  314.                     msg += "in uso in Porte Applicative: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  315.                 }
  316.                 break;
  317.             case IN_USO_IN_CANALE_NODO:
  318.                 if ( messages!=null && messages.size() > 0) {
  319.                     msg += "utilizzato nei Nodi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  320.                 }
  321.                 break;
  322.             default:
  323.                 msg += "utilizzato in oggetto non codificato ("+key+")"+separator;
  324.                 break;
  325.             }

  327.         }// chiudo for

  329.         return msg;
  330.     }
  331. }
Created with JaCoCo 0.8.8.202204050719