DBOggettiInUsoUtils_accordiRest.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.CoreException;
  32. import org.openspcoop2.core.commons.DBUtils;
  33. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  34. import org.openspcoop2.core.constants.CostantiDB;
  35. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  36. import org.openspcoop2.core.id.IDAccordo;
  37. import org.openspcoop2.core.id.IDPortaApplicativa;
  38. import org.openspcoop2.core.id.IDResource;
  39. import org.openspcoop2.core.id.IDServizio;
  40. import org.openspcoop2.core.id.IDSoggetto;
  41. import org.openspcoop2.core.mapping.DBMappingUtils;
  42. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  43. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  44. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  45. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  46. import org.openspcoop2.protocol.engine.constants.Costanti;
  47. import org.openspcoop2.utils.UtilsException;
  48. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  49. import org.openspcoop2.utils.sql.ISQLQueryObject;
  50. import org.openspcoop2.utils.sql.LikeConfig;
  51. import org.openspcoop2.utils.sql.SQLObjectFactory;

  53. /**
  54.  * DBOggettiInUsoUtils_accordiRest
  55.  * 
  56.  * @author Andrea Poli (apoli@link.it)
  57.  * @author $Author$
  58.  * @version $Rev$, $Date$
  59.  * 
  60.  */
  61. public class DBOggettiInUsoUtils_accordiRest {
  62.     
  63.     private DBOggettiInUsoUtils_accordiRest() {}

  65.     protected static boolean isRisorsaConfigInUso(Connection con, String tipoDB, IDResource idRisorsa, Map<ErrorsHandlerCostant, 
  66.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  67.         return isRisorsaInUsoInternal(con,tipoDB,idRisorsa,false,true,whereIsInUso,normalizeObjectIds);
  68.     }
  69.     protected static boolean isRisorsaRegistryInUso(Connection con, String tipoDB, IDResource idRisorsa, Map<ErrorsHandlerCostant, 
  70.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  71.         return isRisorsaInUsoInternal(con,tipoDB,idRisorsa,true,false,whereIsInUso,normalizeObjectIds);
  72.     }
  73.     protected static boolean isRisorsaInUso(Connection con, String tipoDB, IDResource idRisorsa, Map<ErrorsHandlerCostant, 
  74.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  75.         return isRisorsaInUsoInternal(con,tipoDB,idRisorsa,true,true,whereIsInUso,normalizeObjectIds);
  76.     }
  77.     private static boolean isRisorsaInUsoInternal(Connection con, String tipoDB, IDResource idRisorsa,
  78.             boolean registry, boolean config, Map<ErrorsHandlerCostant, 
  79.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  80.         String nomeMetodo = "_isRisorsaInUso";

  82.         PreparedStatement stmt = null;
  83.         ResultSet risultato = null;
  84.         String queryString;

  86.         try {
  87.         
  88.             boolean isInUso = false;
  89.             
  90.             List<String> correlazioneList = whereIsInUso.get(ErrorsHandlerCostant.IS_CORRELATA);
  91.             
  92.             List<String> porteApplicativeList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  93.             List<String> porteDelegateList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE);
  94.             List<String> mappingErogazionePAList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  95.             List<String> mappingFruizionePDList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD);
  96.             
  97.             List<String> trasformazionePDMappingList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PD);
  98.             List<String> trasformazionePDList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PD);
  99.             List<String> trasformazionePAMappingList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA);
  100.             List<String> trasformazionePAList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PA);
  101.             
  102.             List<String> ctList = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  103.             List<String> allarmeList = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI);
  104.             
  105.             List<String> modiSignalHubList = whereIsInUso.get(ErrorsHandlerCostant.IS_RIFERITA_MODI_SIGNAL_HUB);
  106.             
  107.             if (correlazioneList == null) {
  108.                 correlazioneList = new ArrayList<>();
  109.                 whereIsInUso.put(ErrorsHandlerCostant.IS_CORRELATA, correlazioneList);
  110.             }
  111.             
  112.             if (porteApplicativeList == null) {
  113.                 porteApplicativeList = new ArrayList<>();
  114.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porteApplicativeList);
  115.             }
  116.             if (porteDelegateList == null) {
  117.                 porteDelegateList = new ArrayList<>();
  118.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE, porteDelegateList);
  119.             }
  120.             if (mappingErogazionePAList == null) {
  121.                 mappingErogazionePAList = new ArrayList<>();
  122.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePAList);
  123.             }
  124.             if (mappingFruizionePDList == null) {
  125.                 mappingFruizionePDList = new ArrayList<>();
  126.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePDList);
  127.             }
  128.             
  129.             if (trasformazionePDMappingList == null) {
  130.                 trasformazionePDMappingList = new ArrayList<>();
  131.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PD, trasformazionePDMappingList);
  132.             }
  133.             if (trasformazionePDList == null) {
  134.                 trasformazionePDList = new ArrayList<>();
  135.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PD, trasformazionePDList);
  136.             }
  137.             if (trasformazionePAMappingList == null) {
  138.                 trasformazionePAMappingList = new ArrayList<>();
  139.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA, trasformazionePAMappingList);
  140.             }
  141.             if (trasformazionePAList == null) {
  142.                 trasformazionePAList = new ArrayList<>();
  143.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PA, trasformazionePAList);
  144.             }
  145.             
  146.             if (ctList == null) {
  147.                 ctList = new ArrayList<>();
  148.                 whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ctList);
  149.             }
  150.             if (allarmeList == null) {
  151.                 allarmeList = new ArrayList<>();
  152.                 whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarmeList);
  153.             }
  154.             
  155.             if (modiSignalHubList == null) {
  156.                 modiSignalHubList = new ArrayList<>();
  157.                 whereIsInUso.put(ErrorsHandlerCostant.IS_RIFERITA_MODI_SIGNAL_HUB, modiSignalHubList);
  158.             }
  159.             
  160.             
  161.             
  162.             // recupero id
  163.             
  164.             long idAccordo = DBUtils.getIdAccordoServizioParteComune(idRisorsa.getIdAccordo(), con, tipoDB);
  165.             if(idAccordo<=0) {
  166.                 throw new UtilsException("Accordo non trovato");
  167.             }
  168.             
  169.             long idR = DBUtils.getIdResource(idAccordo, idRisorsa.getNome(), con);
  170.             if(idR<=0) {
  171.                 throw new UtilsException("Risorsa non trovata");
  172.             }
  173.             
  174.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  175.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  176.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  177.             sqlQueryObject.addSelectField("nome_servizio");
  178.             sqlQueryObject.addSelectField("tipo_servizio");
  179.             sqlQueryObject.addSelectField("versione_servizio");
  180.             sqlQueryObject.addSelectField("nome_soggetto");
  181.             sqlQueryObject.addSelectField("tipo_soggetto");
  182.             sqlQueryObject.setANDLogicOperator(true);
  183.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_accordo=?");
  184.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  185.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".port_type is null"); // condizione per rest
  186.             queryString = sqlQueryObject.createSQLQuery();
  187.             stmt = con.prepareStatement(queryString);
  188.             stmt.setLong(1, idAccordo);
  189.             risultato = stmt.executeQuery();
  190.             List<IDServizio> idServiziWithAccordo = new ArrayList<>();
  191.             while (risultato.next()) {
  192.                 IDSoggetto soggettoErogatore = new IDSoggetto(risultato.getString("tipo_soggetto"), risultato.getString("nome_soggetto"));
  193.                 IDServizio idServizio = 
  194.                         IDServizioFactory.getInstance().getIDServizioFromValues(risultato.getString("tipo_servizio"), 
  195.                                 risultato.getString("nome_servizio"), soggettoErogatore, risultato.getInt("versione_servizio"));
  196.                 idServiziWithAccordo.add(idServizio);
  197.             }
  198.             risultato.close();
  199.             stmt.close();
  200.             
  201.             
  202.             
  203.             
  204.             
  205.             
  206.             // Controllo che l'azione non sia stata correlata da un'altra azione tramite ModI
  207.             if(Costanti.MODIPA_PROTOCOL_NAME.equals(idRisorsa.getIdAccordo().getSoggettoReferente().getTipo())) {
  208.             
  209.                 ISQLQueryObject sqlQueryObjectApiExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  210.                 sqlQueryObjectApiExists.setANDLogicOperator(true);
  211.                 sqlQueryObjectApiExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  212.                 sqlQueryObjectApiExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  213.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.API_RESOURCES + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  214.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  215.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  216.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");

  218.                 ISQLQueryObject sqlQueryObjectOperationExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  219.                 sqlQueryObjectOperationExists.setANDLogicOperator(true);
  220.                 sqlQueryObjectOperationExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  221.                 sqlQueryObjectOperationExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  222.                 sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.API_RESOURCES + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  223.                 sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  224.                 sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  225.                 sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  226.                 
  227.                 
  228.                 // Verifico correlazione PULL (all'interno del solito accordo)
  229.                 
  230.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  231.                 sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES);
  232.                 sqlQueryObject.addWhereCondition(CostantiDB.API_RESOURCES + ".id_accordo = ?");
  233.                 sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"nome","nomeRisorsaCorrelata");
  234.                 sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"http_method","httpMethodRisorsaCorrelata");
  235.                 sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"path","pathRisorsaCorrelata");
  236.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectApiExists);
  237.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectOperationExists);
  238.                 sqlQueryObject.setANDLogicOperator(true);
  239.                 sqlQueryObject.addOrderBy("pathRisorsaCorrelata");
  240.                 sqlQueryObject.addOrderBy("httpMethodRisorsaCorrelata");
  241.                 sqlQueryObject.setSortType(true);
  242.                 queryString = sqlQueryObject.createSQLQuery();
  243.                 stmt = con.prepareStatement(queryString);
  244.                 int index = 1;
  245.                 stmt.setLong(index++, idAccordo);
  246.                 // sqlQueryObjectApiExists
  247.                 stmt.setString(index++, ProprietariProtocolProperty.RESOURCE.name());
  248.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA);
  249.                 stmt.setString(index++, Costanti.MODIPA_VALUE_UNDEFINED);
  250.                 // sqlQueryObjectOperationExists
  251.                 stmt.setString(index++, ProprietariProtocolProperty.RESOURCE.name());
  252.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_AZIONE_RICHIESTA_CORRELATA);
  253.                 stmt.setString(index++, idRisorsa.getNome());
  254.                 risultato = stmt.executeQuery();
  255.                 while (risultato.next()){
  256.                     @SuppressWarnings("unused")
  257.                     String nomeRisorsaCorrelata = risultato.getString("nomeRisorsaCorrelata");
  258.                     String httpMethodRisorsaCorrelata = risultato.getString("httpMethodRisorsaCorrelata");
  259.                     String pathRisorsaCorrelata = risultato.getString("pathRisorsaCorrelata");
  260.                     
  261.                     String path = null;
  262.                     if(pathRisorsaCorrelata==null || "".equals(pathRisorsaCorrelata)) {
  263.                         path = "*";
  264.                     }
  265.                     else {
  266.                         path = pathRisorsaCorrelata;
  267.                     }
  268.                     
  269.                     String method = null;
  270.                     if(httpMethodRisorsaCorrelata==null || "".equals(httpMethodRisorsaCorrelata)) {
  271.                         method = "Qualsiasi";
  272.                     }
  273.                     else {
  274.                         method = httpMethodRisorsaCorrelata;
  275.                     }
  276.                     
  277.                     correlazioneList.add("Risorsa "+method+" "+path+" (interazione: NonBloccante-Pull)");
  278.                     isInUso = true;
  279.                 }
  280.                 risultato.close();
  281.                 stmt.close();
  282.                 
  283.                 // Verifico correlazione PUSH
  284.                 
  285.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  286.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  287.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  288.                 sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES);
  289.                 sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"nome","nomeRisorsaCorrelata");
  290.                 sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"http_method","httpMethodRisorsaCorrelata");
  291.                 sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"path","pathRisorsaCorrelata");
  292.                 sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"nome","nomeApi");
  293.                 sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"versione","versioneApi");
  294.                 sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"tipo_soggetto","tipoReferenteApi");
  295.                 sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"nome_soggetto","nomeReferenteApi");
  296.                 sqlQueryObject.addWhereCondition(CostantiDB.API_RESOURCES + ".id_accordo = " + CostantiDB.ACCORDI + ".id");
  297.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI + ".id = " + CostantiDB.ACCORDI + ".id_referente");
  298.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectApiExists);
  299.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectOperationExists);
  300.                 sqlQueryObject.setANDLogicOperator(true);
  301.                 sqlQueryObject.addOrderBy("nomeApi");
  302.                 sqlQueryObject.addOrderBy("versioneApi");
  303.                 sqlQueryObject.addOrderBy("nomeReferenteApi");
  304.                 sqlQueryObject.addOrderBy("tipoReferenteApi");
  305.                 sqlQueryObject.addOrderBy("pathRisorsaCorrelata");
  306.                 sqlQueryObject.addOrderBy("httpMethodRisorsaCorrelata");
  307.                 sqlQueryObject.setSortType(true);
  308.                 queryString = sqlQueryObject.createSQLQuery();
  309.                 stmt = con.prepareStatement(queryString);
  310.                 index = 1;
  311.                 // sqlQueryObjectApiExists
  312.                 stmt.setString(index++, ProprietariProtocolProperty.RESOURCE.name());
  313.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA);
  314.                 stmt.setString(index++, IDAccordoFactory.getInstance().getUriFromIDAccordo(idRisorsa.getIdAccordo()));
  315.                 // sqlQueryObjectOperationExists
  316.                 stmt.setString(index++, ProprietariProtocolProperty.RESOURCE.name());
  317.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_AZIONE_RICHIESTA_CORRELATA);
  318.                 stmt.setString(index++, idRisorsa.getNome());
  319.                 risultato = stmt.executeQuery();
  320.                 IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  321.                 while (risultato.next()){
  322.                     
  323.                     String nomeApi = risultato.getString("nomeApi");
  324.                     int versioneApi = risultato.getInt("versioneApi");
  325.                     String tipoReferenteApi = risultato.getString("tipoReferenteApi");
  326.                     String nomeReferenteApi = risultato.getString("nomeReferenteApi");
  327.                     IDAccordo idAPI = idAccordoFactory.getIDAccordoFromValues(nomeApi, tipoReferenteApi, nomeReferenteApi, versioneApi);
  328.                     
  329.                     @SuppressWarnings("unused")
  330.                     String nomeRisorsaCorrelata = risultato.getString("nomeRisorsaCorrelata");
  331.                     String httpMethodRisorsaCorrelata = risultato.getString("httpMethodRisorsaCorrelata");
  332.                     String pathRisorsaCorrelata = risultato.getString("pathRisorsaCorrelata");
  333.                     
  334.                     String path = null;
  335.                     if(pathRisorsaCorrelata==null || "".equals(pathRisorsaCorrelata)) {
  336.                         path = "*";
  337.                     }
  338.                     else {
  339.                         path = pathRisorsaCorrelata;
  340.                     }
  341.                     
  342.                     String method = null;
  343.                     if(httpMethodRisorsaCorrelata==null || "".equals(httpMethodRisorsaCorrelata)) {
  344.                         method = "Qualsiasi";
  345.                     }
  346.                     else {
  347.                         method = httpMethodRisorsaCorrelata;
  348.                     }
  349.                     
  350.                     correlazioneList.add("Risorsa "+method+" "+path+" dell'API '"+idAccordoFactory.getUriFromIDAccordo(idAPI)+"' (interazione: NonBloccante-Push)");
  351.                     isInUso = true;
  352.                 }
  353.                 risultato.close();
  354.                 stmt.close();
  355.                 
  356.             }
  357.             
  358.             
  359.             
  360.             

  362.             
  363.             // Porte delegate, mapping
  364.             if(config &&
  365.                 idServiziWithAccordo!=null && !idServiziWithAccordo.isEmpty()) {
  366.                 for (IDServizio idServizio : idServiziWithAccordo) {
  367.                     
  368.                     long idS = DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(),
  369.                             idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(),
  370.                             con, tipoDB);
  371.                     if(idS<=0) {
  372.                         throw new CoreException("Servizio '"+idServizio+"' non esistente");
  373.                     }
  374.                     
  375.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  376.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  377.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  378.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_FRUITORI,"id","idFruitore");
  379.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".tipo_soggetto");
  380.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".nome_soggetto");
  381.                     sqlQueryObject.addSelectField(CostantiDB.SERVIZI_FRUITORI + ".id_servizio");
  382.                     sqlQueryObject.addSelectField(CostantiDB.SERVIZI_FRUITORI + ".id_soggetto");
  383.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".id");
  384.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI + ".id_servizio = ?");
  385.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI + ".id_soggetto = " + CostantiDB.SOGGETTI + ".id");
  386.                     sqlQueryObject.setANDLogicOperator(true);
  387.                     sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI + ".tipo_soggetto");
  388.                     sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI + ".nome_soggetto");
  389.                     sqlQueryObject.setSortType(true);
  390.                     queryString = sqlQueryObject.createSQLQuery();
  391.                     stmt = con.prepareStatement(queryString);
  392.                     stmt.setLong(1, idS);
  393.                     risultato = stmt.executeQuery();
  394.                     List<IDSoggetto> listFruitori = new ArrayList<>();
  395.                     while (risultato.next()){
  396.                         listFruitori.add(new IDSoggetto(risultato.getString("tipo_soggetto"),risultato.getString("nome_soggetto")));
  397.                     }
  398.                     risultato.close();
  399.                     stmt.close();
  400.                     
  401.                     
  402.                     if(listFruitori!=null && !listFruitori.isEmpty()) {
  403.                     
  404.                         for (IDSoggetto idSoggettoFruitore : listFruitori) {
  405.                             List<MappingFruizionePortaDelegata> lPD = DBMappingUtils.mappingFruizionePortaDelegataList(con, tipoDB, idSoggettoFruitore, idServizio, true);
  406.                             if(lPD!=null && !lPD.isEmpty()) {
  407.                                 for (MappingFruizionePortaDelegata mapping : lPD) {
  408.                                     
  409.                                     
  410.                                     // ** mapping **
  411.                                     
  412.                                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  413.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  414.                                     sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  415.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  416.                                     sqlQueryObject.addSelectField("nome_porta");
  417.                                     sqlQueryObject.setANDLogicOperator(true);
  418.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta=?");
  419.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id="+CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta");
  420.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  421.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".azione=?");
  422.                                     queryString = sqlQueryObject.createSQLQuery();
  423.                                     stmt = con.prepareStatement(queryString);
  424.                                     stmt.setString(1, mapping.getIdPortaDelegata().getNome());
  425.                                     stmt.setString(2, idRisorsa.getNome());
  426.                                     risultato = stmt.executeQuery();
  427.                                     while (risultato.next()){
  428.                                         String nome = risultato.getString("nome_porta");
  429.                                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  430.                                         if(resultPorta.mapping) {
  431.                                             mappingFruizionePDList.add(resultPorta.label);
  432.                                         }
  433.                                         else {
  434.                                             porteDelegateList.add(resultPorta.label);
  435.                                         }
  436.                                         isInUso = true;
  437.                                     }
  438.                                     risultato.close();
  439.                                     stmt.close();
  440.                                     
  441.                                     
  442.                                     // ** trasformazioni **
  443.                                     
  444.                                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  445.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI);
  446.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  447.                                     sqlQueryObject.addSelectField("nome_porta");
  448.                                     sqlQueryObject.setANDLogicOperator(true);
  449.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta=?");
  450.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  451.                                     // condizione di controllo
  452.                                     ISQLQueryObject sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  453.                                     sqlQueryObjectOr.setANDLogicOperator(false);
  454.                                     // (applicabilita_azioni == 'NOME') OR (applicabilita_azioni like 'NOME,%') OR (applicabilita_azioni like '%,NOME') OR (applicabilita_azioni like '%,applicabilita_azioni,%')
  455.                                     /** CLOB sqlQueryObjectOr.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni = ?");*/
  456.                                     sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni", idRisorsa.getNome(), false , false);
  457.                                     sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni", idRisorsa.getNome()+",", LikeConfig.startsWith(false));
  458.                                     sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni", ","+idRisorsa.getNome(), LikeConfig.endsWith(false));
  459.                                     sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni", ","+idRisorsa.getNome()+",", true , false);
  460.                                     sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  461.                                     queryString = sqlQueryObject.createSQLQuery();
  462.                                     stmt = con.prepareStatement(queryString);
  463.                                     stmt.setString(1, mapping.getIdPortaDelegata().getNome());
  464.                                     /** CLOB stmt.setString(2, idRisorsa.getNome());*/
  465.                                     risultato = stmt.executeQuery();
  466.                                     while (risultato.next()){
  467.                                         String nome = risultato.getString("nome_porta");
  468.                                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  469.                                         if(resultPorta.mapping) {
  470.                                             trasformazionePDMappingList.add(resultPorta.label);
  471.                                         }
  472.                                         else {
  473.                                             trasformazionePDList.add(resultPorta.label);
  474.                                         }
  475.                                         isInUso = true;
  476.                                     }
  477.                                     risultato.close();
  478.                                     stmt.close();
  479.                                     
  480.                                     
  481.                                     // ** Controllo che non sia associato a policy di controllo del traffico o allarmi **
  482.                                     
  483.                                     int max = 2;
  484.                                     if(!CostantiDB.isAllarmiEnabled()) {
  485.                                         max=1;
  486.                                     }
  487.                                     for (int i = 0; i < max; i++) {
  488.                                         
  489.                                         String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  490.                                         String identificativoColumn = "active_policy_id";
  491.                                         String aliasColumn = "policy_alias";
  492.                                         List<String> list = ctList;
  493.                                         String oggetto = "Policy";
  494.                                         if(i==1) {
  495.                                             tabella = CostantiDB.ALLARMI;
  496.                                             identificativoColumn = "nome";
  497.                                             aliasColumn = "alias";
  498.                                             list = allarmeList;
  499.                                             oggetto = "Allarme";
  500.                                         }
  501.                                     
  502.                                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  503.                                         sqlQueryObject.addFromTable(tabella);
  504.                                         sqlQueryObject.addSelectField(identificativoColumn);
  505.                                         sqlQueryObject.addSelectField(aliasColumn);
  506.                                         sqlQueryObject.addSelectField("filtro_ruolo");
  507.                                         sqlQueryObject.addSelectField("filtro_porta");
  508.                                         sqlQueryObject.setANDLogicOperator(true);
  509.                                         sqlQueryObject.addWhereCondition(tabella+".filtro_ruolo=?");
  510.                                         sqlQueryObject.addWhereCondition(tabella+".filtro_porta=?");
  511.                                         
  512.                                         // condizione di controllo
  513.                                         sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  514.                                         sqlQueryObjectOr.setANDLogicOperator(false);
  515.                                         // (filtro_azione == 'NOME') OR (filtro_azione like 'NOME,%') OR (filtro_azione like '%,NOME') OR (filtro_azione like '%,applicabilita_azioni,%')
  516.                                         /** CLOB sqlQueryObjectOr.addWhereCondition(CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".filtro_azione = ?");*/
  517.                                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idRisorsa.getNome(), false , false);
  518.                                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idRisorsa.getNome()+",", LikeConfig.startsWith(false));
  519.                                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idRisorsa.getNome(), LikeConfig.endsWith(false));
  520.                                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idRisorsa.getNome()+",", true , false);
  521.                                         sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  522.                                         
  523.                                         sqlQueryObject.addOrderBy("filtro_ruolo");
  524.                                         sqlQueryObject.addOrderBy("filtro_porta");
  525.                                         queryString = sqlQueryObject.createSQLQuery();
  526.                                         stmt = con.prepareStatement(queryString);
  527.                                         stmt.setString(1, "delegata");
  528.                                         stmt.setString(2, mapping.getIdPortaDelegata().getNome());
  529.                                         /** CLOB stmt.setString(3, idRisorsa.getNome());*/
  530.                                         risultato = stmt.executeQuery();
  531.                                         while (risultato.next()) {
  532.                                             
  533.                                             String alias = risultato.getString(aliasColumn);
  534.                                             if(alias== null || "".equals(alias)) {
  535.                                                 alias = risultato.getString(identificativoColumn);
  536.                                             }
  537.                                             
  538.                                             String nomePorta = risultato.getString("filtro_porta");
  539.                                             String filtroRuolo = risultato.getString("filtro_ruolo");
  540.                                             if(nomePorta!=null) {
  541.                                                 String tipo = null;
  542.                                                 String label = null;
  543.                                                 if("delegata".equals(filtroRuolo)) {
  544.                                                     try {
  545.                                                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  546.                                                         if(resultPorta.mapping) {
  547.                                                             label = "Fruizione di Servizio "+ resultPorta.label;
  548.                                                         }
  549.                                                     }catch(Exception e) {
  550.                                                         tipo = "Outbound";
  551.                                                     }
  552.                                                 }
  553.                                                 else {
  554.                                                     tipo = filtroRuolo;
  555.                                                 }
  556.                                                 if(label==null) {
  557.                                                     list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  558.                                                 }
  559.                                                 else {
  560.                                                     list.add(oggetto+" '"+alias+"' attiva nella "+label);
  561.                                                 }
  562.                                             }
  563.                                             else {
  564.                                                 list.add(oggetto+" '"+alias+"'");
  565.                                             }
  566.                             
  567.                                             isInUso = true;
  568.                                         }
  569.                                         risultato.close();
  570.                                         stmt.close();
  571.                                     }
  572.                                 }
  573.                             }
  574.                         }
  575.                         
  576.                     }
  577.                 }
  578.             }
  579.                 
  580.             
  581.                 
  582.                 
  583.             // Porte applicative, mapping
  584.             if(config &&
  585.                 idServiziWithAccordo!=null && !idServiziWithAccordo.isEmpty()) {
  586.                 for (IDServizio idServizio : idServiziWithAccordo) {
  587.                     List<MappingErogazionePortaApplicativa> lPA = DBMappingUtils.mappingErogazionePortaApplicativaList(con, tipoDB, idServizio, true);
  588.                     if(lPA!=null && !lPA.isEmpty()) {
  589.                         for (MappingErogazionePortaApplicativa mapping : lPA) {
  590.                             
  591.                             
  592.                             // ** mapping **
  593.                             
  594.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  595.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  596.                             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  597.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AZIONI);
  598.                             sqlQueryObject.addSelectField("nome_porta");
  599.                             sqlQueryObject.setANDLogicOperator(true);
  600.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta=?");
  601.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta");
  602.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_AZIONI+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  603.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_AZIONI+".azione=?");
  604.                             queryString = sqlQueryObject.createSQLQuery();
  605.                             stmt = con.prepareStatement(queryString);
  606.                             stmt.setString(1, mapping.getIdPortaApplicativa().getNome());
  607.                             stmt.setString(2, idRisorsa.getNome());
  608.                             risultato = stmt.executeQuery();
  609.                             while (risultato.next()){
  610.                                 String nome = risultato.getString("nome_porta");
  611.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  612.                                 if(resultPorta.mapping) {
  613.                                     mappingErogazionePAList.add(resultPorta.label);
  614.                                 }
  615.                                 else {
  616.                                     porteApplicativeList.add(resultPorta.label);
  617.                                 }
  618.                                 isInUso = true;
  619.                             }
  620.                             risultato.close();
  621.                             stmt.close();
  622.                             
  623.                             
  624.                             // ** trasformazioni **
  625.                             
  626.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  627.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI);
  628.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  629.                             sqlQueryObject.addSelectField("nome_porta");
  630.                             sqlQueryObject.setANDLogicOperator(true);
  631.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta=?");
  632.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  633.                             // condizione di controllo
  634.                             ISQLQueryObject sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  635.                             sqlQueryObjectOr.setANDLogicOperator(false);
  636.                             // (applicabilita_azioni == 'NOME') OR (applicabilita_azioni like 'NOME,%') OR (applicabilita_azioni like '%,NOME') OR (applicabilita_azioni like '%,applicabilita_azioni,%')
  637.                             /** CLOB sqlQueryObjectOr.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni = ?");*/
  638.                             sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni", idRisorsa.getNome(), false , false);
  639.                             sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni", idRisorsa.getNome()+",", LikeConfig.startsWith(false));
  640.                             sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni", ","+idRisorsa.getNome(), LikeConfig.endsWith(false));
  641.                             sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni", ","+idRisorsa.getNome()+",", true , false);
  642.                             sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  643.                             queryString = sqlQueryObject.createSQLQuery();
  644.                             stmt = con.prepareStatement(queryString);
  645.                             stmt.setString(1, mapping.getIdPortaApplicativa().getNome());
  646.                             /** CLOB stmt.setString(2, idRisorsa.getNome());*/
  647.                             risultato = stmt.executeQuery();
  648.                             while (risultato.next()){
  649.                                 String nome = risultato.getString("nome_porta");
  650.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  651.                                 if(resultPorta.mapping) {
  652.                                     trasformazionePAMappingList.add(resultPorta.label);
  653.                                 }
  654.                                 else {
  655.                                     trasformazionePAList.add(resultPorta.label);
  656.                                 }
  657.                                 isInUso = true;
  658.                             }
  659.                             risultato.close();
  660.                             stmt.close();
  661.                             
  662.                             
  663.                             // ** Controllo che non sia associato a policy di controllo del traffico o allarmi **
  664.                             
  665.                             int max = 2;
  666.                             if(!CostantiDB.isAllarmiEnabled()) {
  667.                                 max=1;
  668.                             }
  669.                             for (int i = 0; i < max; i++) {
  670.                                 
  671.                                 String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  672.                                 String identificativoColumn = "active_policy_id";
  673.                                 String aliasColumn = "policy_alias";
  674.                                 List<String> list = ctList;
  675.                                 String oggetto = "Policy";
  676.                                 if(i==1) {
  677.                                     tabella = CostantiDB.ALLARMI;
  678.                                     identificativoColumn = "nome";
  679.                                     aliasColumn = "alias";
  680.                                     list = allarmeList;
  681.                                     oggetto = "Allarme";
  682.                                 }
  683.                             
  684.                                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  685.                                 sqlQueryObject.addFromTable(tabella);
  686.                                 sqlQueryObject.addSelectField(identificativoColumn);
  687.                                 sqlQueryObject.addSelectField(aliasColumn);
  688.                                 sqlQueryObject.addSelectField("filtro_ruolo");
  689.                                 sqlQueryObject.addSelectField("filtro_porta");
  690.                                 sqlQueryObject.setANDLogicOperator(true);
  691.                                 sqlQueryObject.addWhereCondition(tabella+".filtro_ruolo=?");
  692.                                 sqlQueryObject.addWhereCondition(tabella+".filtro_porta=?");
  693.                                 
  694.                                 // condizione di controllo
  695.                                 sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  696.                                 sqlQueryObjectOr.setANDLogicOperator(false);
  697.                                 // (filtro_azione == 'NOME') OR (filtro_azione like 'NOME,%') OR (filtro_azione like '%,NOME') OR (filtro_azione like '%,applicabilita_azioni,%')
  698.                                 /** CLOB sqlQueryObjectOr.addWhereCondition(CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".filtro_azione = ?");*/
  699.                                 sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idRisorsa.getNome(), false , false);
  700.                                 sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idRisorsa.getNome()+",", LikeConfig.startsWith(false));
  701.                                 sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idRisorsa.getNome(), LikeConfig.endsWith(false));
  702.                                 sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idRisorsa.getNome()+",", true , false);
  703.                                 sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  704.                                 
  705.                                 sqlQueryObject.addOrderBy("filtro_ruolo");
  706.                                 sqlQueryObject.addOrderBy("filtro_porta");
  707.                                 queryString = sqlQueryObject.createSQLQuery();
  708.                                 stmt = con.prepareStatement(queryString);
  709.                                 stmt.setString(1, "applicativa");
  710.                                 stmt.setString(2, mapping.getIdPortaApplicativa().getNome());
  711.                                 /** CLOB stmt.setString(3, idRisorsa.getNome());*/
  712.                                 risultato = stmt.executeQuery();
  713.                                 while (risultato.next()) {
  714.                                     
  715.                                     String alias = risultato.getString(aliasColumn);
  716.                                     if(alias== null || "".equals(alias)) {
  717.                                         alias = risultato.getString(identificativoColumn);
  718.                                     }
  719.                                     
  720.                                     String nomePorta = risultato.getString("filtro_porta");
  721.                                     String filtroRuolo = risultato.getString("filtro_ruolo");
  722.                                     if(nomePorta!=null) {
  723.                                         String tipo = null;
  724.                                         String label = null;
  725.                                         if("applicativa".equals(filtroRuolo)) {
  726.                                             try {
  727.                                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  728.                                                 if(resultPorta.mapping) {
  729.                                                     label = "Erogazione di Servizio "+ resultPorta.label;
  730.                                                 }
  731.                                             }catch(Exception e) {
  732.                                                 tipo = "Inbound";
  733.                                             }
  734.                                         }
  735.                                         else {
  736.                                             tipo = filtroRuolo;
  737.                                         }
  738.                                         if(label==null) {
  739.                                             list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  740.                                         }
  741.                                         else {
  742.                                             list.add(oggetto+" '"+alias+"' attiva nella "+label);
  743.                                         }
  744.                                     }
  745.                                     else {
  746.                                         list.add(oggetto+" '"+alias+"'");
  747.                                     }
  748.                     
  749.                                     isInUso = true;
  750.                                 }
  751.                                 risultato.close();
  752.                                 stmt.close();
  753.                             }
  754.                         }
  755.                     }
  756.                 }
  757.             }
  758.             
  759.             
  760.             
  761.             
  762.             
  763.             
  764.             // ** Controllo che non sia associato a policy di controllo del traffico o allarmi generali **
  765.             
  766.             long idAccordoServizioParteComune = DBUtils.getIdAccordoServizioParteComune(idRisorsa.getIdAccordo(), con, tipoDB);
  767.             if(idAccordoServizioParteComune<=0){
  768.                 throw new UtilsException("Accordi di Servizio Parte Comune con id ["+idRisorsa.getIdAccordo().toString()+"] non trovato");
  769.             }
  770.             
  771.             // Recupero servizi che implementano l'accordo
  772.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  773.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  774.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  775.             sqlQueryObject.addSelectField("*");
  776.             sqlQueryObject.addWhereCondition("id_accordo = ?");
  777.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  778.             sqlQueryObject.setANDLogicOperator(true);
  779.             queryString = sqlQueryObject.createSQLQuery();
  780.             stmt = con.prepareStatement(queryString);
  781.             stmt.setLong(1, idAccordoServizioParteComune);
  782.             risultato = stmt.executeQuery();
  783.             List<IDServizio> listIDServizio = new ArrayList<>();
  784.             while (risultato.next()){
  785.                 String tipoSoggettoErogatore = risultato.getString("tipo_soggetto");
  786.                 String nomeSoggettoErogatore = risultato.getString("nome_soggetto");
  787.                 String tipoServizio = risultato.getString("tipo_servizio");
  788.                 String nomeServizio = risultato.getString("nome_servizio");
  789.                 int versioneServizio = risultato.getInt("versione_servizio");
  790.                 IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipoServizio, nomeServizio, 
  791.                         tipoSoggettoErogatore, nomeSoggettoErogatore, versioneServizio);
  792.                 listIDServizio.add(idServizio);
  793.             }
  794.             risultato.close();
  795.             stmt.close();
  796.             
  797.             if(!listIDServizio.isEmpty()) {
  798.             
  799.                 for (IDServizio idServizio : listIDServizio) {
  800.                     
  801.                     int max = 2;
  802.                     if(!CostantiDB.isAllarmiEnabled()) {
  803.                         max=1;
  804.                     }
  805.                     for (int i = 0; i < max; i++) {
  806.                         
  807.                         String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  808.                         String identificativoColumn = "active_policy_id";
  809.                         String aliasColumn = "policy_alias";
  810.                         List<String> list = ctList;
  811.                         String oggetto = "Policy";
  812.                         if(i==1) {
  813.                             tabella = CostantiDB.ALLARMI;
  814.                             identificativoColumn = "nome";
  815.                             aliasColumn = "alias";
  816.                             list = allarmeList;
  817.                             oggetto = "Allarme";
  818.                         }
  819.                     
  820.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  821.                         sqlQueryObject.addFromTable(tabella);
  822.                         sqlQueryObject.setSelectDistinct(true);
  823.                         sqlQueryObject.addSelectField(identificativoColumn);
  824.                         sqlQueryObject.addSelectField(aliasColumn);
  825.                         sqlQueryObject.setANDLogicOperator(true);
  826.                         sqlQueryObject.addWhereIsNullCondition(tabella+".filtro_porta");
  827.                         
  828.                         ISQLQueryObject sqlQueryObjectServizioCompleto = SQLObjectFactory.createSQLQueryObject(tipoDB);
  829.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_tipo_erogatore=?");
  830.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_nome_erogatore=?");
  831.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_tipo_servizio=?");
  832.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_nome_servizio=?");
  833.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_versione_servizio=?");
  834.                         
  835.                         ISQLQueryObject sqlQueryObjectServizioParziale = SQLObjectFactory.createSQLQueryObject(tipoDB);
  836.                         sqlQueryObjectServizioParziale.addWhereIsNullCondition(tabella+".filtro_tipo_erogatore");
  837.                         sqlQueryObjectServizioParziale.addWhereIsNullCondition(tabella+".filtro_nome_erogatore");
  838.                         sqlQueryObjectServizioParziale.addWhereCondition(tabella+".filtro_tipo_servizio=?");
  839.                         sqlQueryObjectServizioParziale.addWhereCondition(tabella+".filtro_nome_servizio=?");
  840.                         sqlQueryObjectServizioParziale.addWhereCondition(tabella+".filtro_versione_servizio=?");
  841.                         
  842.                         sqlQueryObject.addWhereCondition(false,false, sqlQueryObjectServizioCompleto.createSQLConditions(), sqlQueryObjectServizioParziale.createSQLConditions());
  843.                         
  844.                         // condizione di controllo
  845.                         ISQLQueryObject sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  846.                         sqlQueryObjectOr.setANDLogicOperator(false);
  847.                         // (filtro_azione == 'NOME') OR (filtro_azione like 'NOME,%') OR (filtro_azione like '%,NOME') OR (filtro_azione like '%,applicabilita_azioni,%')
  848.                         /** CLOB sqlQueryObjectOr.addWhereCondition(CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY+".filtro_azione = ?");*/
  849.                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idRisorsa.getNome(), false , false);
  850.                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idRisorsa.getNome()+",", LikeConfig.startsWith(false));
  851.                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idRisorsa.getNome(), LikeConfig.endsWith(false));
  852.                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idRisorsa.getNome()+",", true , false);
  853.                         sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  854.                         
  855.                         sqlQueryObject.addOrderBy(aliasColumn);
  856.                         sqlQueryObject.addOrderBy(identificativoColumn);
  857.                         queryString = sqlQueryObject.createSQLQuery();
  858.                         stmt = con.prepareStatement(queryString);
  859.                         int index = 1;
  860.                         stmt.setString(index++, idServizio.getSoggettoErogatore().getTipo());
  861.                         stmt.setString(index++, idServizio.getSoggettoErogatore().getNome());
  862.                         stmt.setString(index++, idServizio.getTipo());
  863.                         stmt.setString(index++, idServizio.getNome());
  864.                         stmt.setInt(index++, idServizio.getVersione());
  865.                         stmt.setString(index++, idServizio.getTipo());
  866.                         stmt.setString(index++, idServizio.getNome());
  867.                         stmt.setInt(index++, idServizio.getVersione());
  868.                         /** CLOB stmt.setString(index++, idRisorsa.getNome());*/
  869.                         risultato = stmt.executeQuery();
  870.                         while (risultato.next()) {
  871.                             
  872.                             String alias = risultato.getString(aliasColumn);
  873.                             if(alias== null || "".equals(alias)) {
  874.                                 alias = risultato.getString(identificativoColumn);
  875.                             }
  876.                             
  877.                             String oggettoTrovato = oggetto+" '"+alias+"'";
  878.                             if(!list.contains(oggettoTrovato)) {
  879.                                 list.add(oggettoTrovato);
  880.                             }
  881.             
  882.                             isInUso = true;
  883.                         }
  884.                         risultato.close();
  885.                         stmt.close();
  886.                     }
  887.                 }
  888.             }
  889.             
  890.             
  891.             
  892.             
  893.             
  894.             
  895.             
  896.             // ** Controllo che non sia riferito dalla configurazione SignalHub **
  897.             if(registry && Costanti.MODIPA_PROTOCOL_NAME.equals(idRisorsa.getIdAccordo().getSoggettoReferente().getTipo()) &&
  898.                 idServiziWithAccordo!=null && !idServiziWithAccordo.isEmpty()) {
  899.                 for (IDServizio idServizio : idServiziWithAccordo) {
  900.                                     
  901.                     long idS = DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(),
  902.                             idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(),
  903.                             con, tipoDB);
  904.                     if(idS<=0) {
  905.                         throw new CoreException("Servizio '"+idServizio+"' non esistente");
  906.                     }
  907.                         
  908.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  909.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  910.                     sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  911.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI,"id","idServizio");
  912.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI + ".id = ?");
  913.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  914.                     sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  915.                     sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  916.                     sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  917.                     sqlQueryObject.setANDLogicOperator(true);
  918.                     queryString = sqlQueryObject.createSQLQuery();
  919.                     stmt = con.prepareStatement(queryString);
  920.                     int index = 1;
  921.                     stmt.setLong(index++, idS);
  922.                     stmt.setString(index++, ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA.name());
  923.                     stmt.setString(index++, Costanti.MODIPA_API_IMPL_INFO_SIGNAL_HUB_OPERATION_ID);
  924.                     stmt.setString(index++, idRisorsa.getNome());
  925.                     risultato = stmt.executeQuery();
  926.                     if(risultato.next()) {
  927.                         
  928.                         // trovata
  929.                         IDPortaApplicativa idPA = DBMappingUtils.getIDPortaApplicativaAssociataDefault(idServizio, con, tipoDB);
  930.                         if(idPA!=null) {
  931.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(idPA.getNome(), tipoDB, con, normalizeObjectIds);
  932.                             modiSignalHubList.add(resultPorta.label);
  933.                         }
  934.                         else {
  935.                             modiSignalHubList.add(idServizio.toString());
  936.                         }
  937.                         
  938.                         isInUso = true;
  939.                         
  940.                     }
  941.                 }
  942.             }
  943.             
  944.             

  946.             return isInUso;

  948.         } catch (Exception se) {
  949.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  950.         } finally {
  951.             // Chiudo statement and resultset
  952.             JDBCUtilities.closeResources(risultato, stmt);
  953.         }
  954.     }


  957.     protected static String toString(IDResource idRisorsa, String methodPath, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  958.         return toString(idRisorsa, methodPath, whereIsInUso, prefix, separator," non eliminabile perch&egrave; :");
  959.     }
  960.     protected static String toString(IDResource idRisorsa, String methodPath, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  961.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  962.         StringBuilder msgBuilder = new StringBuilder("Risorsa '"+(methodPath!=null ? methodPath : idRisorsa.getNome())+"'" + intestazione+separator);
  963.         if(!prefix){
  964.             msgBuilder = new StringBuilder("");
  965.         }
  966.         String separatorCategorie = "";
  967.         if(whereIsInUso.size()>1) {
  968.             separatorCategorie = separator;
  969.         }
  970.         for (ErrorsHandlerCostant key : keys) {
  971.             List<String> messages = whereIsInUso.get(key);

  973.             if ( messages!=null && !messages.isEmpty()) {
  974.                 msgBuilder.append(separatorCategorie);
  975.             }
  976.             
  977.             switch (key) {

  979.             case IS_CORRELATA:
  980.                 if ( messages!=null && !messages.isEmpty()) {
  981.                     msgBuilder.append("correlata ad altre risorse: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  982.                 }
  983.                 break;
  984.             
  985.             case IN_USO_IN_PORTE_APPLICATIVE:
  986.                 if ( messages!=null && !messages.isEmpty()) {
  987.                     msgBuilder.append("appartenente ad un gruppo differente da quello predefinito nelle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  988.                 }
  989.                 break;
  990.             case IN_USO_IN_PORTE_DELEGATE:
  991.                 if ( messages!=null && !messages.isEmpty()) {
  992.                     msgBuilder.append("appartenente ad un gruppo differente da quello predefinito nelle Porte Outbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  993.                 }
  994.                 break;
  995.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  996.                 if ( messages!=null && !messages.isEmpty()) {
  997.                     msgBuilder.append("appartenente ad un gruppo differente da quello predefinito nelle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  998.                 }
  999.                 break;
  1000.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  1001.                 if ( messages!=null && !messages.isEmpty()) {
  1002.                     msgBuilder.append("appartenente ad un gruppo differente da quello predefinito nelle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1003.                 }
  1004.                 break;
  1005.                 
  1006.             case TRASFORMAZIONE_MAPPING_PD:
  1007.                 if ( messages!=null && !messages.isEmpty()) {
  1008.                     msgBuilder.append("utilizzata nel criterio di applicabilità della Trasformazione (Risorse) per le Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1009.                 }
  1010.                 break;
  1011.             case TRASFORMAZIONE_PD:
  1012.                 if ( messages!=null && !messages.isEmpty()) {
  1013.                     msgBuilder.append("utilizzata nelle Porte Outbound (Criterio di applicabilità della Trasformazione - Risorse): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1014.                 }
  1015.                 break;
  1016.             case TRASFORMAZIONE_MAPPING_PA:
  1017.                 if ( messages!=null && !messages.isEmpty()) {
  1018.                     msgBuilder.append("utilizzata nel criterio di applicabilità della Trasformazione (Risorse) per le Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1019.                 }
  1020.                 break;
  1021.             case TRASFORMAZIONE_PA:
  1022.                 if ( messages!=null && !messages.isEmpty()) {
  1023.                     msgBuilder.append("utilizzata nelle Porte Inbound (Criterio di applicabilità della Trasformazione - Risorse): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1024.                 }
  1025.                 break;
  1026.                                 
  1027.             case CONTROLLO_TRAFFICO:
  1028.                 if ( messages!=null && !messages.isEmpty() ) {
  1029.                     msgBuilder.append("utilizzata in Policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1030.                 }
  1031.                 break;
  1032.             case ALLARMI:
  1033.                 if ( messages!=null && !messages.isEmpty() ) {
  1034.                     msgBuilder.append("utilizzato in Allarmi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1035.                 }
  1036.                 break;
  1037.                 
  1038.             case IS_RIFERITA_MODI_SIGNAL_HUB:
  1039.                 if ( messages!=null && !messages.isEmpty() ) {
  1040.                     msgBuilder.append("riferito nella configurazione 'SignalHub' dell'erogazione: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1041.                 }
  1042.                 break;
  1043.                 
  1044.             default:
  1045.                 msgBuilder.append("utilizzata in oggetto non codificato ("+key+")"+separator);
  1046.                 break;
  1047.             }
  1048.             
  1049.         }// chiudo for

  1051.         return msgBuilder.toString();
  1052.     }
  1053.     
  1054. }
Created with JaCoCo 0.8.8.202204050719