DBOggettiInUsoUtils_accordiSoap.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.IDPortType;
  38. import org.openspcoop2.core.id.IDPortTypeAzione;
  39. import org.openspcoop2.core.id.IDPortaApplicativa;
  40. import org.openspcoop2.core.id.IDServizio;
  41. import org.openspcoop2.core.id.IDSoggetto;
  42. import org.openspcoop2.core.mapping.DBMappingUtils;
  43. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  44. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  45. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  46. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  47. import org.openspcoop2.protocol.engine.constants.Costanti;
  48. import org.openspcoop2.protocol.engine.constants.ModalitaIdentificazioneAzione;
  49. import org.openspcoop2.utils.UtilsException;
  50. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  51. import org.openspcoop2.utils.sql.ISQLQueryObject;
  52. import org.openspcoop2.utils.sql.LikeConfig;
  53. import org.openspcoop2.utils.sql.SQLObjectFactory;

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

  67.     protected static boolean isPortTypeConfigInUso(Connection con, String tipoDB, IDPortType idPT, Map<ErrorsHandlerCostant, 
  68.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  69.         return isPortTypeInUsoInternal(con,tipoDB,idPT,false,true,whereIsInUso,normalizeObjectIds);
  70.     }
  71.     protected static boolean isPortTypeRegistryInUso(Connection con, String tipoDB, IDPortType idPT, Map<ErrorsHandlerCostant, 
  72.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  73.         return isPortTypeInUsoInternal(con,tipoDB,idPT,true,false,whereIsInUso,normalizeObjectIds);
  74.     }
  75.     protected static boolean isPortTypeInUso(Connection con, String tipoDB, IDPortType idPT, Map<ErrorsHandlerCostant, 
  76.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  77.         return isPortTypeInUsoInternal(con,tipoDB,idPT,true,true,whereIsInUso,normalizeObjectIds);
  78.     }
  79.     private static boolean isPortTypeInUsoInternal(Connection con, String tipoDB, IDPortType idPT,
  80.             boolean registry, boolean config, Map<ErrorsHandlerCostant, 
  81.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  82.         String nomeMetodo = "_isPortTypeInUso";

  84.         PreparedStatement stmt = null;
  85.         ResultSet risultato = null;
  86.         String queryString;

  88.         try {
  89.         
  90.             if(registry) {
  91.                 // nop
  92.             }
  93.             
  94.             boolean isInUso = false;
  95.             
  96.             List<String> correlazioneList = whereIsInUso.get(ErrorsHandlerCostant.IS_CORRELATA);
  97.             
  98.             List<String> porteApplicativeList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  99.             List<String> porteDelegateList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE);
  100.             List<String> mappingErogazionePAList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  101.             List<String> mappingFruizionePDList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD);
  102.                         
  103.             if (correlazioneList == null) {
  104.                 correlazioneList = new ArrayList<>();
  105.                 whereIsInUso.put(ErrorsHandlerCostant.IS_CORRELATA, correlazioneList);
  106.             }
  107.             
  108.             if (porteApplicativeList == null) {
  109.                 porteApplicativeList = new ArrayList<>();
  110.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porteApplicativeList);
  111.             }
  112.             if (porteDelegateList == null) {
  113.                 porteDelegateList = new ArrayList<>();
  114.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE, porteDelegateList);
  115.             }
  116.             if (mappingErogazionePAList == null) {
  117.                 mappingErogazionePAList = new ArrayList<>();
  118.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePAList);
  119.             }
  120.             if (mappingFruizionePDList == null) {
  121.                 mappingFruizionePDList = new ArrayList<>();
  122.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePDList);
  123.             }
  124.             
  125.             
  126.             
  127.             // recupero id
  128.             
  129.             long idAccordo = DBUtils.getIdAccordoServizioParteComune(idPT.getIdAccordo(), con, tipoDB);
  130.             if(idAccordo<=0) {
  131.                 throw new UtilsException("Accordo non trovato");
  132.             }
  133.                         
  134.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  135.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  136.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  137.             sqlQueryObject.addSelectField("nome_servizio");
  138.             sqlQueryObject.addSelectField("tipo_servizio");
  139.             sqlQueryObject.addSelectField("versione_servizio");
  140.             sqlQueryObject.addSelectField("nome_soggetto");
  141.             sqlQueryObject.addSelectField("tipo_soggetto");
  142.             sqlQueryObject.setANDLogicOperator(true);
  143.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_accordo=?");
  144.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  145.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".port_type=?"); // condizione per soap
  146.             queryString = sqlQueryObject.createSQLQuery();
  147.             stmt = con.prepareStatement(queryString);
  148.             stmt.setLong(1, idAccordo);
  149.             stmt.setString(2, idPT.getNome());
  150.             risultato = stmt.executeQuery();
  151.             List<IDServizio> idServiziWithAccordo = new ArrayList<>();
  152.             while (risultato.next()) {
  153.                 IDSoggetto soggettoErogatore = new IDSoggetto(risultato.getString("tipo_soggetto"), risultato.getString("nome_soggetto"));
  154.                 IDServizio idServizio = 
  155.                         IDServizioFactory.getInstance().getIDServizioFromValues(risultato.getString("tipo_servizio"), 
  156.                                 risultato.getString("nome_servizio"), soggettoErogatore, risultato.getInt("versione_servizio"));
  157.                 idServiziWithAccordo.add(idServizio);
  158.             }
  159.             risultato.close();
  160.             stmt.close();
  161.             

  163.             
  164.             
  165.             
  166.             
  167.             
  168.             // Controllo il servizio non sia stata correlato da un'altra azione
  169.             
  170.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  171.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  172.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  173.             sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE_AZIONI,"nome","nomeAzioneCorrelata");
  174.             sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE,"nome","nomePTCorrelato");
  175.             sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE + ".id_accordo = ?");
  176.             sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id_port_type = " + CostantiDB.PORT_TYPE + ".id");
  177.             sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".correlata_servizio = ?");
  178.             sqlQueryObject.setANDLogicOperator(true);
  179.             sqlQueryObject.addOrderBy("nomePTCorrelato");
  180.             sqlQueryObject.addOrderBy("nomeAzioneCorrelata");
  181.             sqlQueryObject.setSortType(true);
  182.             queryString = sqlQueryObject.createSQLQuery();
  183.             stmt = con.prepareStatement(queryString);
  184.             stmt.setLong(1, idAccordo);
  185.             stmt.setString(2, idPT.getNome());
  186.             risultato = stmt.executeQuery();
  187.             while (risultato.next()){
  188.                 String nomeAzioneCorrelata = risultato.getString("nomeAzioneCorrelata");
  189.                 String nomePTCorrelato = risultato.getString("nomePTCorrelato");
  190.                 correlazioneList.add("Azione "+nomeAzioneCorrelata+" del Servizio "+nomePTCorrelato);
  191.                 isInUso = true;
  192.             }
  193.             risultato.close();
  194.             stmt.close();
  195.             
  196.             
  197.             
  198.             
  199.             
  200.             // Controllo che l'azione non sia stata correlata da un'altra azione tramite ModI
  201.             if(Costanti.MODIPA_PROTOCOL_NAME.equals(idPT.getIdAccordo().getSoggettoReferente().getTipo())) {
  202.             
  203.                 ISQLQueryObject sqlQueryObjectApiExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  204.                 sqlQueryObjectApiExists.setANDLogicOperator(true);
  205.                 sqlQueryObjectApiExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  206.                 sqlQueryObjectApiExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  207.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  208.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  209.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  210.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  211.                 
  212.                 ISQLQueryObject sqlQueryObjectPortTypeExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  213.                 sqlQueryObjectPortTypeExists.setANDLogicOperator(true);
  214.                 sqlQueryObjectPortTypeExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  215.                 sqlQueryObjectPortTypeExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  216.                 sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  217.                 sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  218.                 sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  219.                 sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  220.                 
  221.                                 
  222.                 // Verifico correlazione PUSH
  223.                 
  224.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  225.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  226.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  227.                 sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  228.                 sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  229.                 sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE_AZIONI,"nome","nomeAzioneCorrelata");
  230.                 sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE,"nome","nomePTCorrelato");
  231.                 sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"nome","nomeApi");
  232.                 sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"versione","versioneApi");
  233.                 sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"tipo_soggetto","tipoReferenteApi");
  234.                 sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"nome_soggetto","nomeReferenteApi");
  235.                 sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE + ".id_accordo = " + CostantiDB.ACCORDI + ".id");
  236.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI + ".id = " + CostantiDB.ACCORDI + ".id_referente");
  237.                 sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id_port_type = " + CostantiDB.PORT_TYPE + ".id");
  238.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectApiExists);
  239.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectPortTypeExists);
  240.                 sqlQueryObject.setANDLogicOperator(true);
  241.                 sqlQueryObject.addOrderBy("nomeApi");
  242.                 sqlQueryObject.addOrderBy("versioneApi");
  243.                 sqlQueryObject.addOrderBy("nomeReferenteApi");
  244.                 sqlQueryObject.addOrderBy("tipoReferenteApi");
  245.                 sqlQueryObject.addOrderBy("nomePTCorrelato");
  246.                 sqlQueryObject.addOrderBy("nomeAzioneCorrelata");
  247.                 sqlQueryObject.setSortType(true);
  248.                 queryString = sqlQueryObject.createSQLQuery();
  249.                 stmt = con.prepareStatement(queryString);
  250.                 int index = 1;
  251.                 // sqlQueryObjectApiExists
  252.                 stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  253.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA);
  254.                 stmt.setString(index++, IDAccordoFactory.getInstance().getUriFromIDAccordo(idPT.getIdAccordo()));
  255.                 // sqlQueryObjectPortTypeExists
  256.                 stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  257.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_SERVIZIO_RICHIESTA_CORRELATA);
  258.                 stmt.setString(index++, idPT.getNome());
  259.                 risultato = stmt.executeQuery();
  260.                 IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  261.                 while (risultato.next()){
  262.                     String nomeAzioneCorrelata = risultato.getString("nomeAzioneCorrelata");
  263.                     String nomePTCorrelato = risultato.getString("nomePTCorrelato");
  264.                     String nomeApi = risultato.getString("nomeApi");
  265.                     int versioneApi = risultato.getInt("versioneApi");
  266.                     String tipoReferenteApi = risultato.getString("tipoReferenteApi");
  267.                     String nomeReferenteApi = risultato.getString("nomeReferenteApi");
  268.                     IDAccordo idAPI = idAccordoFactory.getIDAccordoFromValues(nomeApi, tipoReferenteApi, nomeReferenteApi, versioneApi);
  269.                     correlazioneList.add("Azione "+nomeAzioneCorrelata+" del Servizio "+nomePTCorrelato+" dell'API '"+idAccordoFactory.getUriFromIDAccordo(idAPI)+"' (interazione: NonBloccante-Push)");
  270.                     isInUso = true;
  271.                 }
  272.                 risultato.close();
  273.                 stmt.close();
  274.                 
  275.             }
  276.             
  277.             
  278.             
  279.             
  280.             
  281.             
  282.             
  283.             // Porte delegate, mapping
  284.             if(config &&
  285.                 idServiziWithAccordo!=null && !idServiziWithAccordo.isEmpty()) {
  286.                 for (IDServizio idServizio : idServiziWithAccordo) {
  287.                     
  288.                     long idS = DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(),
  289.                             idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(),
  290.                             con, tipoDB);
  291.                     if(idS<=0) {
  292.                         throw new CoreException("Servizio '"+idServizio+"' non esistente");
  293.                     }
  294.                     
  295.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  296.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  297.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  298.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_FRUITORI,"id","idFruitore");
  299.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".tipo_soggetto");
  300.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".nome_soggetto");
  301.                     sqlQueryObject.addSelectField(CostantiDB.SERVIZI_FRUITORI + ".id_servizio");
  302.                     sqlQueryObject.addSelectField(CostantiDB.SERVIZI_FRUITORI + ".id_soggetto");
  303.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".id");
  304.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI + ".id_servizio = ?");
  305.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI + ".id_soggetto = " + CostantiDB.SOGGETTI + ".id");
  306.                     sqlQueryObject.setANDLogicOperator(true);
  307.                     sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI + ".tipo_soggetto");
  308.                     sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI + ".nome_soggetto");
  309.                     sqlQueryObject.setSortType(true);
  310.                     queryString = sqlQueryObject.createSQLQuery();
  311.                     stmt = con.prepareStatement(queryString);
  312.                     stmt.setLong(1, idS);
  313.                     risultato = stmt.executeQuery();
  314.                     List<IDSoggetto> listFruitori = new ArrayList<>();
  315.                     while (risultato.next()){
  316.                         listFruitori.add(new IDSoggetto(risultato.getString("tipo_soggetto"),risultato.getString("nome_soggetto")));
  317.                     }
  318.                     risultato.close();
  319.                     stmt.close();
  320.                     
  321.                     
  322.                     if(listFruitori!=null && !listFruitori.isEmpty()) {
  323.                     
  324.                         for (IDSoggetto idSoggettoFruitore : listFruitori) {
  325.                             List<MappingFruizionePortaDelegata> lPD = DBMappingUtils.mappingFruizionePortaDelegataList(con, tipoDB, idSoggettoFruitore, idServizio, true);
  326.                             if(lPD!=null && !lPD.isEmpty()) {
  327.                                 for (MappingFruizionePortaDelegata mapping : lPD) {
  328.                                     if(!mapping.isDefault()) {
  329.                                         // segnalo solo quelle di default, non ha senso segnalarte tutte
  330.                                         continue;
  331.                                     }
  332.                                     String nome = mapping.getIdPortaDelegata().getNome();
  333.                                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  334.                                     if(resultPorta.mapping) {
  335.                                         mappingFruizionePDList.add(resultPorta.label);
  336.                                     }
  337.                                     else {
  338.                                         porteDelegateList.add(resultPorta.label);
  339.                                     }
  340.                                     isInUso = true;
  341.                                 }
  342.                             }
  343.                         }
  344.                         
  345.                     }
  346.                 }
  347.             }
  348.                 
  349.             
  350.                 
  351.                 
  352.             // Porte applicative, mapping
  353.             if(config &&
  354.                 idServiziWithAccordo!=null && !idServiziWithAccordo.isEmpty()) {
  355.                 for (IDServizio idServizio : idServiziWithAccordo) {
  356.                     List<MappingErogazionePortaApplicativa> lPA = DBMappingUtils.mappingErogazionePortaApplicativaList(con, tipoDB, idServizio, true);
  357.                     if(lPA!=null && !lPA.isEmpty()) {
  358.                         for (MappingErogazionePortaApplicativa mapping : lPA) {
  359.                             if(!mapping.isDefault()) {
  360.                                 // segnalo solo quelle di default, non ha senso segnalarte tutte
  361.                                 continue;
  362.                             }
  363.                             String nome = mapping.getIdPortaApplicativa().getNome();
  364.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  365.                             if(resultPorta.mapping) {
  366.                                 mappingErogazionePAList.add(resultPorta.label);
  367.                             }
  368.                             else {
  369.                                 porteApplicativeList.add(resultPorta.label);
  370.                             }
  371.                             isInUso = true;
  372.                         }
  373.                     }
  374.                 }
  375.             }
  376.                 
  377.             
  378.             return isInUso;

  380.         } catch (Exception se) {
  381.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  382.         } finally {
  383.             // Chiudo statement and resultset
  384.             JDBCUtilities.closeResources(risultato, stmt);
  385.         }
  386.     }


  389.     protected static String toString(IDPortType idPT, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  390.         return toString(idPT, whereIsInUso, prefix, separator," non eliminabile perch&egrave; :");
  391.     }
  392.     protected static String toString(IDPortType idPT, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  393.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  394.         StringBuilder msgBuilder = new StringBuilder("Servizio '"+(idPT.getNome())+"'" + intestazione+separator);
  395.         if(!prefix){
  396.             msgBuilder = new StringBuilder("");
  397.         }
  398.         String separatorCategorie = "";
  399.         if(whereIsInUso.size()>1) {
  400.             separatorCategorie = separator;
  401.         }
  402.         for (ErrorsHandlerCostant key : keys) {
  403.             List<String> messages = whereIsInUso.get(key);

  405.             if ( messages!=null && !messages.isEmpty()) {
  406.                 msgBuilder.append(separatorCategorie);
  407.             }
  408.             
  409.             switch (key) {

  411.             case IS_CORRELATA:
  412.                 if ( messages!=null && !messages.isEmpty()) {
  413.                     msgBuilder.append("correlato verso altre azioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  414.                 }
  415.                 break;
  416.             
  417.             case IN_USO_IN_PORTE_APPLICATIVE:
  418.                 if ( messages!=null && !messages.isEmpty()) {
  419.                     msgBuilder.append("utilizzato nelle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  420.                 }
  421.                 break;
  422.             case IN_USO_IN_PORTE_DELEGATE:
  423.                 if ( messages!=null && !messages.isEmpty()) {
  424.                     msgBuilder.append("utilizzato nelle Porte Outbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  425.                 }
  426.                 break;          
  427.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  428.                 if ( messages!=null && !messages.isEmpty()) {
  429.                     msgBuilder.append("utilizzato nelle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  430.                 }
  431.                 break;
  432.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  433.                 if ( messages!=null && !messages.isEmpty()) {
  434.                     msgBuilder.append("utilizzato nelle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  435.                 }
  436.                 break;
  437.                 
  438.             default:
  439.                 msgBuilder.append("utilizzata in oggetto non codificato ("+key+")"+separator);
  440.                 break;
  441.             }
  442.             
  443.         }// chiudo for

  445.         return msgBuilder.toString();
  446.     }
  447.     
  448.     
  449.     
  450.     
  451.     
  452.     
  453.     
  454.     
  455.     
  456.     
  457.     
  458.     
  459.     
  460.     
  461.     
  462.     // ***** OPERATION ******

  464.     protected static boolean isOperazioneConfigInUso(Connection con, String tipoDB, IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, 
  465.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  466.         return isOperazioneInUsoInternal(con,tipoDB,idOperazione,false,true,whereIsInUso,normalizeObjectIds);
  467.     }
  468.     protected static boolean isOperazioneRegistryInUso(Connection con, String tipoDB, IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, 
  469.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  470.         return isOperazioneInUsoInternal(con,tipoDB,idOperazione,true,false,whereIsInUso,normalizeObjectIds);
  471.     }
  472.     protected static boolean isOperazioneInUso(Connection con, String tipoDB, IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, 
  473.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  474.         return isOperazioneInUsoInternal(con,tipoDB,idOperazione,true,true,whereIsInUso,normalizeObjectIds);
  475.     }
  476.     private static boolean isOperazioneInUsoInternal(Connection con, String tipoDB, IDPortTypeAzione idOperazione,
  477.             boolean registry, boolean config, Map<ErrorsHandlerCostant, 
  478.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  479.         String nomeMetodo = "_isOperazioneInUso";

  481.         PreparedStatement stmt = null;
  482.         ResultSet risultato = null;
  483.         String queryString;

  485.         try {
  486.         
  487.             boolean isInUso = false;
  488.             
  489.             List<String> correlazioneList = whereIsInUso.get(ErrorsHandlerCostant.IS_CORRELATA);
  490.             
  491.             List<String> porteApplicativeList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  492.             List<String> porteDelegateList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE);
  493.             List<String> mappingErogazionePAList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  494.             List<String> mappingFruizionePDList = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD);
  495.             
  496.             List<String> trasformazionePDMappingList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PD);
  497.             List<String> trasformazionePDList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PD);
  498.             List<String> trasformazionePAMappingLis = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA);
  499.             List<String> trasformazionePAList = whereIsInUso.get(ErrorsHandlerCostant.TRASFORMAZIONE_PA);
  500.             
  501.             List<String> urlInvocazionePDMappingList = whereIsInUso.get(ErrorsHandlerCostant.URLINVOCAZIONE_MAPPING_PD);
  502.             List<String> urlInvocazionePDList = whereIsInUso.get(ErrorsHandlerCostant.URLINVOCAZIONE_PD);
  503.             List<String> urlInvocazionePAMappingList = whereIsInUso.get(ErrorsHandlerCostant.URLINVOCAZIONE_MAPPING_PA);
  504.             List<String> urlInvocazionePAList = whereIsInUso.get(ErrorsHandlerCostant.URLINVOCAZIONE_PA);
  505.             
  506.             List<String> ctList = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  507.             List<String> allarmeList = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI);
  508.             
  509.             List<String> modiSignalHubList = whereIsInUso.get(ErrorsHandlerCostant.IS_RIFERITA_MODI_SIGNAL_HUB);
  510.             
  511.             if (correlazioneList == null) {
  512.                 correlazioneList = new ArrayList<>();
  513.                 whereIsInUso.put(ErrorsHandlerCostant.IS_CORRELATA, correlazioneList);
  514.             }
  515.             
  516.             if (porteApplicativeList == null) {
  517.                 porteApplicativeList = new ArrayList<>();
  518.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porteApplicativeList);
  519.             }
  520.             if (porteDelegateList == null) {
  521.                 porteDelegateList = new ArrayList<>();
  522.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE, porteDelegateList);
  523.             }
  524.             if (mappingErogazionePAList == null) {
  525.                 mappingErogazionePAList = new ArrayList<>();
  526.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePAList);
  527.             }
  528.             if (mappingFruizionePDList == null) {
  529.                 mappingFruizionePDList = new ArrayList<>();
  530.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePDList);
  531.             }
  532.             
  533.             if (trasformazionePDMappingList == null) {
  534.                 trasformazionePDMappingList = new ArrayList<>();
  535.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PD, trasformazionePDMappingList);
  536.             }
  537.             if (trasformazionePDList == null) {
  538.                 trasformazionePDList = new ArrayList<>();
  539.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PD, trasformazionePDList);
  540.             }
  541.             if (trasformazionePAMappingLis == null) {
  542.                 trasformazionePAMappingLis = new ArrayList<>();
  543.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_MAPPING_PA, trasformazionePAMappingLis);
  544.             }
  545.             if (trasformazionePAList == null) {
  546.                 trasformazionePAList = new ArrayList<>();
  547.                 whereIsInUso.put(ErrorsHandlerCostant.TRASFORMAZIONE_PA, trasformazionePAList);
  548.             }
  549.             
  550.             if (urlInvocazionePDMappingList == null) {
  551.                 urlInvocazionePDMappingList = new ArrayList<>();
  552.                 whereIsInUso.put(ErrorsHandlerCostant.URLINVOCAZIONE_MAPPING_PD, urlInvocazionePDMappingList);
  553.             }
  554.             if (urlInvocazionePDList == null) {
  555.                 urlInvocazionePDList = new ArrayList<>();
  556.                 whereIsInUso.put(ErrorsHandlerCostant.URLINVOCAZIONE_PD, urlInvocazionePDList);
  557.             }
  558.             if (urlInvocazionePAMappingList == null) {
  559.                 urlInvocazionePAMappingList = new ArrayList<>();
  560.                 whereIsInUso.put(ErrorsHandlerCostant.URLINVOCAZIONE_MAPPING_PA, urlInvocazionePAMappingList);
  561.             }
  562.             if (urlInvocazionePAList == null) {
  563.                 urlInvocazionePAList = new ArrayList<>();
  564.                 whereIsInUso.put(ErrorsHandlerCostant.URLINVOCAZIONE_PA, urlInvocazionePAList);
  565.             }
  566.             
  567.             if (ctList == null) {
  568.                 ctList = new ArrayList<>();
  569.                 whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ctList);
  570.             }
  571.             if (allarmeList == null) {
  572.                 allarmeList = new ArrayList<>();
  573.                 whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarmeList);
  574.             }
  575.             
  576.             if (modiSignalHubList == null) {
  577.                 modiSignalHubList = new ArrayList<>();
  578.                 whereIsInUso.put(ErrorsHandlerCostant.IS_RIFERITA_MODI_SIGNAL_HUB, modiSignalHubList);
  579.             }
  580.             
  581.             
  582.             
  583.             // recupero id
  584.             
  585.             long idAccordo = DBUtils.getIdAccordoServizioParteComune(idOperazione.getIdPortType().getIdAccordo(), con, tipoDB);
  586.             if(idAccordo<=0) {
  587.                 throw new UtilsException("Accordo non trovato");
  588.             }
  589.             
  590.             
  591.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  592.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  593.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  594.             sqlQueryObject.addSelectField("nome_servizio");
  595.             sqlQueryObject.addSelectField("tipo_servizio");
  596.             sqlQueryObject.addSelectField("versione_servizio");
  597.             sqlQueryObject.addSelectField("nome_soggetto");
  598.             sqlQueryObject.addSelectField("tipo_soggetto");
  599.             sqlQueryObject.setANDLogicOperator(true);
  600.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_accordo=?");
  601.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  602.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".port_type=?"); // condizione per soap
  603.             queryString = sqlQueryObject.createSQLQuery();
  604.             stmt = con.prepareStatement(queryString);
  605.             stmt.setLong(1, idAccordo);
  606.             stmt.setString(2, idOperazione.getIdPortType().getNome());
  607.             risultato = stmt.executeQuery();
  608.             List<IDServizio> idServiziWithAccordo = new ArrayList<>();
  609.             while (risultato.next()) {
  610.                 IDSoggetto soggettoErogatore = new IDSoggetto(risultato.getString("tipo_soggetto"), risultato.getString("nome_soggetto"));
  611.                 IDServizio idServizio = 
  612.                         IDServizioFactory.getInstance().getIDServizioFromValues(risultato.getString("tipo_servizio"), 
  613.                                 risultato.getString("nome_servizio"), soggettoErogatore, risultato.getInt("versione_servizio"));
  614.                 idServiziWithAccordo.add(idServizio);
  615.             }
  616.             risultato.close();
  617.             stmt.close();
  618.             
  619.             
  620.             
  621.             
  622.             
  623.             // Controllo che l'azione non sia stata correlata da un'altra azione
  624.             
  625.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  626.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  627.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  628.             sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE_AZIONI,"nome","nomeAzioneCorrelata");
  629.             sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE,"nome","nomePTCorrelato");
  630.             sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE_AZIONI,"correlata_servizio","correlataServizio");
  631.             sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE + ".id_accordo = ?");
  632.             sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id_port_type = " + CostantiDB.PORT_TYPE + ".id");
  633.             
  634.             ISQLQueryObject sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  635.             sqlQueryObjectOr.setANDLogicOperator(false);
  636.             // asincrono asimmetrico
  637.             sqlQueryObjectOr.addWhereCondition(true, 
  638.                     CostantiDB.PORT_TYPE_AZIONI + ".correlata = ?",
  639.                     (CostantiDB.PORT_TYPE_AZIONI + ".correlata_servizio is null OR "+CostantiDB.PORT_TYPE_AZIONI + ".correlata_servizio = ?"),
  640.                     CostantiDB.PORT_TYPE + ".nome = ?");
  641.             // asincrono simmetrico
  642.             sqlQueryObjectOr.addWhereCondition(true,
  643.                     CostantiDB.PORT_TYPE_AZIONI + ".correlata = ?",
  644.                     CostantiDB.PORT_TYPE_AZIONI + ".correlata_servizio = ?",
  645.                     CostantiDB.PORT_TYPE + ".nome <> ?");
  646.             sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  647.             
  648.             sqlQueryObject.setANDLogicOperator(true);
  649.             sqlQueryObject.addOrderBy("nomePTCorrelato");
  650.             sqlQueryObject.addOrderBy("nomeAzioneCorrelata");
  651.             sqlQueryObject.setSortType(true);
  652.             queryString = sqlQueryObject.createSQLQuery();
  653.             stmt = con.prepareStatement(queryString);
  654.             int index = 1;
  655.             stmt.setLong(index++, idAccordo);
  656.             // asincrono asimmetrico
  657.             stmt.setString(index++, idOperazione.getNome());
  658.             stmt.setString(index++, "");
  659.             stmt.setString(index++, idOperazione.getIdPortType().getNome());
  660.             // asincrono simmetrico
  661.             stmt.setString(index++, idOperazione.getNome());
  662.             stmt.setString(index++, idOperazione.getIdPortType().getNome());
  663.             stmt.setString(index++, idOperazione.getIdPortType().getNome());
  664.             risultato = stmt.executeQuery();
  665.             while (risultato.next()){
  666.                 String nomeAzioneCorrelata = risultato.getString("nomeAzioneCorrelata");
  667.                 String nomePTCorrelato = risultato.getString("nomePTCorrelato");
  668.                 String correlataServizio = risultato.getString("correlataServizio");
  669.                 if(correlataServizio!=null && !"".equals(correlataServizio)) {
  670.                     correlazioneList.add("Azione "+nomeAzioneCorrelata+" del Servizio "+nomePTCorrelato);
  671.                 }
  672.                 else {
  673.                     correlazioneList.add("Azione "+nomeAzioneCorrelata);
  674.                 }
  675.                 isInUso = true;
  676.             }
  677.             risultato.close();
  678.             stmt.close();
  679.             
  680.             
  681.             
  682.             
  683.             
  684.             // Controllo che l'azione non sia stata correlata da un'altra azione tramite ModI
  685.             if(Costanti.MODIPA_PROTOCOL_NAME.equals(idOperazione.getIdPortType().getIdAccordo().getSoggettoReferente().getTipo())) {
  686.             
  687.                 ISQLQueryObject sqlQueryObjectApiExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  688.                 sqlQueryObjectApiExists.setANDLogicOperator(true);
  689.                 sqlQueryObjectApiExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  690.                 sqlQueryObjectApiExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  691.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  692.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  693.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  694.                 sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  695.                 
  696.                 ISQLQueryObject sqlQueryObjectPortTypeExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  697.                 sqlQueryObjectPortTypeExists.setANDLogicOperator(true);
  698.                 sqlQueryObjectPortTypeExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  699.                 sqlQueryObjectPortTypeExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  700.                 sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  701.                 sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  702.                 sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  703.                 sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  704.                 
  705.                 ISQLQueryObject sqlQueryObjectOperationExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  706.                 sqlQueryObjectOperationExists.setANDLogicOperator(true);
  707.                 sqlQueryObjectOperationExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  708.                 sqlQueryObjectOperationExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  709.                 sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  710.                 sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  711.                 sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  712.                 sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  713.                 
  714.                 
  715.                 // Verifico correlazione PULL (all'interno del solito accordo)
  716.                 
  717.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  718.                 sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  719.                 sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  720.                 sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE_AZIONI,"nome","nomeAzioneCorrelata");
  721.                 sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE + ".id_accordo = ?");
  722.                 sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE + ".nome = ?");
  723.                 sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id_port_type = " + CostantiDB.PORT_TYPE + ".id");
  724.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectApiExists);
  725.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectPortTypeExists);
  726.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectOperationExists);
  727.                 sqlQueryObject.setANDLogicOperator(true);
  728.                 sqlQueryObject.addOrderBy("nomeAzioneCorrelata");
  729.                 sqlQueryObject.setSortType(true);
  730.                 queryString = sqlQueryObject.createSQLQuery();
  731.                 stmt = con.prepareStatement(queryString);
  732.                 index = 1;
  733.                 stmt.setLong(index++, idAccordo);
  734.                 stmt.setString(index++, idOperazione.getIdPortType().getNome());
  735.                 // sqlQueryObjectApiExists
  736.                 stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  737.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA);
  738.                 stmt.setString(index++, Costanti.MODIPA_VALUE_UNDEFINED);
  739.                 // sqlQueryObjectPortTypeExists
  740.                 stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  741.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_SERVIZIO_RICHIESTA_CORRELATA);
  742.                 stmt.setString(index++, Costanti.MODIPA_VALUE_UNDEFINED);
  743.                 // sqlQueryObjectOperationExists
  744.                 stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  745.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_AZIONE_RICHIESTA_CORRELATA);
  746.                 stmt.setString(index++, idOperazione.getNome());
  747.                 risultato = stmt.executeQuery();
  748.                 while (risultato.next()){
  749.                     String nomeAzioneCorrelata = risultato.getString("nomeAzioneCorrelata");
  750.                     correlazioneList.add("Azione "+nomeAzioneCorrelata+" (interazione: NonBloccante-Pull)");
  751.                     isInUso = true;
  752.                 }
  753.                 risultato.close();
  754.                 stmt.close();
  755.                 
  756.                 // Verifico correlazione PUSH
  757.                 
  758.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  759.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  760.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  761.                 sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  762.                 sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  763.                 sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE_AZIONI,"nome","nomeAzioneCorrelata");
  764.                 sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE,"nome","nomePTCorrelato");
  765.                 sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"nome","nomeApi");
  766.                 sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"versione","versioneApi");
  767.                 sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"tipo_soggetto","tipoReferenteApi");
  768.                 sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"nome_soggetto","nomeReferenteApi");
  769.                 sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE + ".id_accordo = " + CostantiDB.ACCORDI + ".id");
  770.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI + ".id = " + CostantiDB.ACCORDI + ".id_referente");
  771.                 sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id_port_type = " + CostantiDB.PORT_TYPE + ".id");
  772.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectApiExists);
  773.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectPortTypeExists);
  774.                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectOperationExists);
  775.                 sqlQueryObject.setANDLogicOperator(true);
  776.                 sqlQueryObject.addOrderBy("nomeApi");
  777.                 sqlQueryObject.addOrderBy("versioneApi");
  778.                 sqlQueryObject.addOrderBy("nomeReferenteApi");
  779.                 sqlQueryObject.addOrderBy("tipoReferenteApi");
  780.                 sqlQueryObject.addOrderBy("nomePTCorrelato");
  781.                 sqlQueryObject.addOrderBy("nomeAzioneCorrelata");
  782.                 sqlQueryObject.setSortType(true);
  783.                 queryString = sqlQueryObject.createSQLQuery();
  784.                 stmt = con.prepareStatement(queryString);
  785.                 index = 1;
  786.                 // sqlQueryObjectApiExists
  787.                 stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  788.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA);
  789.                 stmt.setString(index++, IDAccordoFactory.getInstance().getUriFromIDAccordo(idOperazione.getIdPortType().getIdAccordo()));
  790.                 // sqlQueryObjectPortTypeExists
  791.                 stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  792.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_SERVIZIO_RICHIESTA_CORRELATA);
  793.                 stmt.setString(index++, idOperazione.getIdPortType().getNome());
  794.                 // sqlQueryObjectOperationExists
  795.                 stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  796.                 stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_AZIONE_RICHIESTA_CORRELATA);
  797.                 stmt.setString(index++, idOperazione.getNome());
  798.                 risultato = stmt.executeQuery();
  799.                 IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  800.                 while (risultato.next()){
  801.                     String nomeAzioneCorrelata = risultato.getString("nomeAzioneCorrelata");
  802.                     String nomePTCorrelato = risultato.getString("nomePTCorrelato");
  803.                     String nomeApi = risultato.getString("nomeApi");
  804.                     int versioneApi = risultato.getInt("versioneApi");
  805.                     String tipoReferenteApi = risultato.getString("tipoReferenteApi");
  806.                     String nomeReferenteApi = risultato.getString("nomeReferenteApi");
  807.                     IDAccordo idAPI = idAccordoFactory.getIDAccordoFromValues(nomeApi, tipoReferenteApi, nomeReferenteApi, versioneApi);
  808.                     correlazioneList.add("Azione "+nomeAzioneCorrelata+" del Servizio "+nomePTCorrelato+" dell'API '"+idAccordoFactory.getUriFromIDAccordo(idAPI)+"' (interazione: NonBloccante-Push)");
  809.                     isInUso = true;
  810.                 }
  811.                 risultato.close();
  812.                 stmt.close();
  813.                 
  814.             }
  815.             
  816.             
  817.             

  819.             
  820.             // Porte delegate
  821.             if(config &&
  822.                 idServiziWithAccordo!=null && !idServiziWithAccordo.isEmpty()) {
  823.                 for (IDServizio idServizio : idServiziWithAccordo) {
  824.                     
  825.                     long idS = DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(),
  826.                             idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(),
  827.                             con, tipoDB);
  828.                     if(idS<=0) {
  829.                         throw new CoreException("Servizio '"+idServizio+"' non esistente");
  830.                     }
  831.                     
  832.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  833.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  834.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  835.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI_FRUITORI,"id","idFruitore");
  836.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".tipo_soggetto");
  837.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".nome_soggetto");
  838.                     sqlQueryObject.addSelectField(CostantiDB.SERVIZI_FRUITORI + ".id_servizio");
  839.                     sqlQueryObject.addSelectField(CostantiDB.SERVIZI_FRUITORI + ".id_soggetto");
  840.                     sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".id");
  841.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI + ".id_servizio = ?");
  842.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI + ".id_soggetto = " + CostantiDB.SOGGETTI + ".id");
  843.                     sqlQueryObject.setANDLogicOperator(true);
  844.                     sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI + ".tipo_soggetto");
  845.                     sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI + ".nome_soggetto");
  846.                     sqlQueryObject.setSortType(true);
  847.                     queryString = sqlQueryObject.createSQLQuery();
  848.                     stmt = con.prepareStatement(queryString);
  849.                     stmt.setLong(1, idS);
  850.                     risultato = stmt.executeQuery();
  851.                     List<IDSoggetto> listFruitori = new ArrayList<>();
  852.                     while (risultato.next()){
  853.                         listFruitori.add(new IDSoggetto(risultato.getString("tipo_soggetto"),risultato.getString("nome_soggetto")));
  854.                     }
  855.                     risultato.close();
  856.                     stmt.close();
  857.                     
  858.                     
  859.                     if(listFruitori!=null && !listFruitori.isEmpty()) {
  860.                     
  861.                         for (IDSoggetto idSoggettoFruitore : listFruitori) {
  862.                             List<MappingFruizionePortaDelegata> lPD = DBMappingUtils.mappingFruizionePortaDelegataList(con, tipoDB, idSoggettoFruitore, idServizio, true);
  863.                             if(lPD!=null && !lPD.isEmpty()) {
  864.                                 for (MappingFruizionePortaDelegata mapping : lPD) {
  865.                                     
  866.                                     // ** mapping **
  867.                                     
  868.                                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  869.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  870.                                     sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  871.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  872.                                     sqlQueryObject.addSelectField("nome_porta");
  873.                                     sqlQueryObject.setANDLogicOperator(true);
  874.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta=?");
  875.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id="+CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta");
  876.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  877.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".azione=?");
  878.                                     queryString = sqlQueryObject.createSQLQuery();
  879.                                     stmt = con.prepareStatement(queryString);
  880.                                     stmt.setString(1, mapping.getIdPortaDelegata().getNome());
  881.                                     stmt.setString(2, idOperazione.getNome());
  882.                                     risultato = stmt.executeQuery();
  883.                                     while (risultato.next()){
  884.                                         String nome = risultato.getString("nome_porta");
  885.                                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  886.                                         if(resultPorta.mapping) {
  887.                                             mappingFruizionePDList.add(resultPorta.label);
  888.                                         }
  889.                                         else {
  890.                                             porteDelegateList.add(resultPorta.label);
  891.                                         }
  892.                                         isInUso = true;
  893.                                     }
  894.                                     risultato.close();
  895.                                     stmt.close();
  896.                                     
  897.                                     
  898.                                     // ** trasformazioni **
  899.                                     
  900.                                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  901.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI);
  902.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  903.                                     sqlQueryObject.addSelectField("nome_porta");
  904.                                     sqlQueryObject.setANDLogicOperator(true);
  905.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta=?");
  906.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  907.                                     // condizione di controllo
  908.                                     sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  909.                                     sqlQueryObjectOr.setANDLogicOperator(false);
  910.                                     // (applicabilita_azioni == 'NOME') OR (applicabilita_azioni like 'NOME,%') OR (applicabilita_azioni like '%,NOME') OR (applicabilita_azioni like '%,applicabilita_azioni,%')
  911.                                     /** CLOB sqlQueryObjectOr.addWhereCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni = ?");*/
  912.                                     sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni", idOperazione.getNome(), false , false);
  913.                                     sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni", idOperazione.getNome()+",", LikeConfig.startsWith(false));
  914.                                     sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni", ","+idOperazione.getNome(), LikeConfig.endsWith(false));
  915.                                     sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_DELEGATE_TRASFORMAZIONI+".applicabilita_azioni", ","+idOperazione.getNome()+",", true , false);
  916.                                     sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  917.                                     queryString = sqlQueryObject.createSQLQuery();
  918.                                     stmt = con.prepareStatement(queryString);
  919.                                     stmt.setString(1, mapping.getIdPortaDelegata().getNome());
  920.                                     /** CLOB stmt.setString(2, idRisorsa.getNome());*/
  921.                                     risultato = stmt.executeQuery();
  922.                                     while (risultato.next()){
  923.                                         String nome = risultato.getString("nome_porta");
  924.                                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  925.                                         if(resultPorta.mapping) {
  926.                                             trasformazionePDMappingList.add(resultPorta.label);
  927.                                         }
  928.                                         else {
  929.                                             trasformazionePDList.add(resultPorta.label);
  930.                                         }
  931.                                         isInUso = true;
  932.                                     }
  933.                                     risultato.close();
  934.                                     stmt.close();
  935.                                     
  936.                                     
  937.                                     // ** url di invocazione **
  938.                                     
  939.                                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  940.                                     sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  941.                                     sqlQueryObject.addSelectField("nome_porta");
  942.                                     sqlQueryObject.setANDLogicOperator(true);
  943.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta=?");
  944.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".tipo_soggetto_erogatore=?");
  945.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_soggetto_erogatore=?");
  946.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".tipo_servizio=?");
  947.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_servizio=?");
  948.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".versione_servizio=?");
  949.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_azione=?");
  950.                                     sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".mode_azione=?");
  951.                                     queryString = sqlQueryObject.createSQLQuery();
  952.                                     stmt = con.prepareStatement(queryString);
  953.                                     index = 1;
  954.                                     stmt.setString(index++, mapping.getIdPortaDelegata().getNome());
  955.                                     stmt.setString(index++, idServizio.getSoggettoErogatore().getTipo());
  956.                                     stmt.setString(index++, idServizio.getSoggettoErogatore().getNome());
  957.                                     stmt.setString(index++, idServizio.getTipo());
  958.                                     stmt.setString(index++, idServizio.getNome());
  959.                                     stmt.setInt(index++, idServizio.getVersione());
  960.                                     stmt.setString(index++, idOperazione.getNome());
  961.                                     stmt.setString(index++, ModalitaIdentificazioneAzione.STATIC.getValue());
  962.                                     risultato = stmt.executeQuery();
  963.                                     while (risultato.next()){
  964.                                         String nome = risultato.getString("nome_porta");
  965.                                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nome, tipoDB, con, normalizeObjectIds);
  966.                                         if(resultPorta.mapping) {
  967.                                             urlInvocazionePDMappingList.add(resultPorta.label);
  968.                                         }
  969.                                         else {
  970.                                             urlInvocazionePDList.add(resultPorta.label);
  971.                                         }
  972.                                         isInUso = true;
  973.                                     }
  974.                                     risultato.close();
  975.                                     stmt.close();
  976.                                     
  977.                                     
  978.                                     // ** Controllo che non sia associato a policy di controllo del traffico o allarmi **
  979.                                     
  980.                                     int max = 2;
  981.                                     if(!CostantiDB.isAllarmiEnabled()) {
  982.                                         max=1;
  983.                                     }
  984.                                     for (int i = 0; i < max; i++) {
  985.                                         
  986.                                         String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  987.                                         String identificativoColumn = "active_policy_id";
  988.                                         String aliasColumn = "policy_alias";
  989.                                         List<String> list = ctList;
  990.                                         String oggetto = "Policy";
  991.                                         if(i==1) {
  992.                                             tabella = CostantiDB.ALLARMI;
  993.                                             identificativoColumn = "nome";
  994.                                             aliasColumn = "alias";
  995.                                             list = allarmeList;
  996.                                             oggetto = "Allarme";
  997.                                         }
  998.                                     
  999.                                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1000.                                         sqlQueryObject.addFromTable(tabella);
  1001.                                         sqlQueryObject.addSelectField(identificativoColumn);
  1002.                                         sqlQueryObject.addSelectField(aliasColumn);
  1003.                                         sqlQueryObject.addSelectField("filtro_ruolo");
  1004.                                         sqlQueryObject.addSelectField("filtro_porta");
  1005.                                         sqlQueryObject.setANDLogicOperator(true);
  1006.                                         sqlQueryObject.addWhereCondition(tabella+".filtro_ruolo=?");
  1007.                                         sqlQueryObject.addWhereCondition(tabella+".filtro_porta=?");
  1008.                                         
  1009.                                         // condizione di controllo
  1010.                                         sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1011.                                         sqlQueryObjectOr.setANDLogicOperator(false);
  1012.                                         // (filtro_azione == 'NOME') OR (filtro_azione like 'NOME,%') OR (filtro_azione like '%,NOME') OR (filtro_azione like '%,applicabilita_azioni,%')
  1013.                                         /** CLOB sqlQueryObjectOr.addWhereCondition(tabella+".filtro_azione = ?");*/
  1014.                                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idOperazione.getNome(), false , false);
  1015.                                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idOperazione.getNome()+",", LikeConfig.startsWith(false));
  1016.                                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idOperazione.getNome(), LikeConfig.endsWith(false));
  1017.                                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idOperazione.getNome()+",", true , false);
  1018.                                         sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  1019.                                         
  1020.                                         sqlQueryObject.addOrderBy("filtro_ruolo");
  1021.                                         sqlQueryObject.addOrderBy("filtro_porta");
  1022.                                         queryString = sqlQueryObject.createSQLQuery();
  1023.                                         stmt = con.prepareStatement(queryString);
  1024.                                         stmt.setString(1, "delegata");
  1025.                                         stmt.setString(2, mapping.getIdPortaDelegata().getNome());
  1026.                                         /** CLOB stmt.setString(3, idRisorsa.getNome());*/
  1027.                                         risultato = stmt.executeQuery();
  1028.                                         while (risultato.next()) {
  1029.                                             
  1030.                                             String alias = risultato.getString(aliasColumn);
  1031.                                             if(alias== null || "".equals(alias)) {
  1032.                                                 alias = risultato.getString(identificativoColumn);
  1033.                                             }
  1034.                                             
  1035.                                             String nomePorta = risultato.getString("filtro_porta");
  1036.                                             String filtroRuolo = risultato.getString("filtro_ruolo");
  1037.                                             if(nomePorta!=null) {
  1038.                                                 String tipo = null;
  1039.                                                 String label = null;
  1040.                                                 if("delegata".equals(filtroRuolo)) {
  1041.                                                     try {
  1042.                                                         ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  1043.                                                         if(resultPorta.mapping) {
  1044.                                                             label = "Fruizione di Servizio "+ resultPorta.label;
  1045.                                                         }
  1046.                                                     }catch(Exception e) {
  1047.                                                         tipo = "Outbound";
  1048.                                                     }
  1049.                                                 }
  1050.                                                 else {
  1051.                                                     tipo = filtroRuolo;
  1052.                                                 }
  1053.                                                 if(label==null) {
  1054.                                                     list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  1055.                                                 }
  1056.                                                 else {
  1057.                                                     list.add(oggetto+" '"+alias+"' attiva nella "+label);
  1058.                                                 }
  1059.                                             }
  1060.                                             else {
  1061.                                                 list.add(oggetto+" '"+alias+"'");
  1062.                                             }
  1063.                             
  1064.                                             isInUso = true;
  1065.                                         }
  1066.                                         risultato.close();
  1067.                                         stmt.close();
  1068.                                     }
  1069.                                 }
  1070.                             }
  1071.                         }
  1072.                         
  1073.                     }
  1074.                 }
  1075.             }
  1076.                 
  1077.             
  1078.                 
  1079.                 
  1080.             // Porte applicative
  1081.             if(config &&
  1082.                 idServiziWithAccordo!=null && !idServiziWithAccordo.isEmpty()) {
  1083.                 for (IDServizio idServizio : idServiziWithAccordo) {
  1084.                     List<MappingErogazionePortaApplicativa> lPA = DBMappingUtils.mappingErogazionePortaApplicativaList(con, tipoDB, idServizio, true);
  1085.                     if(lPA!=null && !lPA.isEmpty()) {
  1086.                         for (MappingErogazionePortaApplicativa mapping : lPA) {
  1087.                             
  1088.                             // ** mapping **
  1089.                             
  1090.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1091.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  1092.                             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  1093.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_AZIONI);
  1094.                             sqlQueryObject.addSelectField("nome_porta");
  1095.                             sqlQueryObject.setANDLogicOperator(true);
  1096.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta=?");
  1097.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta");
  1098.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_AZIONI+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  1099.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_AZIONI+".azione=?");
  1100.                             queryString = sqlQueryObject.createSQLQuery();
  1101.                             stmt = con.prepareStatement(queryString);
  1102.                             stmt.setString(1, mapping.getIdPortaApplicativa().getNome());
  1103.                             stmt.setString(2, idOperazione.getNome());
  1104.                             risultato = stmt.executeQuery();
  1105.                             while (risultato.next()){
  1106.                                 String nome = risultato.getString("nome_porta");
  1107.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  1108.                                 if(resultPorta.mapping) {
  1109.                                     mappingErogazionePAList.add(resultPorta.label);
  1110.                                 }
  1111.                                 else {
  1112.                                     porteApplicativeList.add(resultPorta.label);
  1113.                                 }
  1114.                                 isInUso = true;
  1115.                             }
  1116.                             risultato.close();
  1117.                             stmt.close();
  1118.                             
  1119.                             
  1120.                             // ** trasformazioni **
  1121.                             
  1122.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1123.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI);
  1124.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  1125.                             sqlQueryObject.addSelectField("nome_porta");
  1126.                             sqlQueryObject.setANDLogicOperator(true);
  1127.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta=?");
  1128.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".id_porta="+CostantiDB.PORTE_APPLICATIVE+".id");
  1129.                             // condizione di controllo
  1130.                             sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1131.                             sqlQueryObjectOr.setANDLogicOperator(false);
  1132.                             // (applicabilita_azioni == 'NOME') OR (applicabilita_azioni like 'NOME,%') OR (applicabilita_azioni like '%,NOME') OR (applicabilita_azioni like '%,applicabilita_azioni,%')
  1133.                             /** CLOB sqlQueryObjectOr.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni = ?");*/
  1134.                             sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni", idOperazione.getNome(), false , false);
  1135.                             sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni", idOperazione.getNome()+",", LikeConfig.startsWith(false));
  1136.                             sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni", ","+idOperazione.getNome(), LikeConfig.endsWith(false));
  1137.                             sqlQueryObjectOr.addWhereLikeCondition(CostantiDB.PORTE_APPLICATIVE_TRASFORMAZIONI+".applicabilita_azioni", ","+idOperazione.getNome()+",", true , false);
  1138.                             sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  1139.                             queryString = sqlQueryObject.createSQLQuery();
  1140.                             stmt = con.prepareStatement(queryString);
  1141.                             stmt.setString(1, mapping.getIdPortaApplicativa().getNome());
  1142.                             /** CLOB stmt.setString(2, idRisorsa.getNome());*/
  1143.                             risultato = stmt.executeQuery();
  1144.                             while (risultato.next()){
  1145.                                 String nome = risultato.getString("nome_porta");
  1146.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  1147.                                 if(resultPorta.mapping) {
  1148.                                     trasformazionePAMappingLis.add(resultPorta.label);
  1149.                                 }
  1150.                                 else {
  1151.                                     trasformazionePAList.add(resultPorta.label);
  1152.                                 }
  1153.                                 isInUso = true;
  1154.                             }
  1155.                             risultato.close();
  1156.                             stmt.close();
  1157.                             
  1158.                             
  1159.                             // ** url di invocazione **
  1160.                             
  1161.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1162.                             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  1163.                             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1164.                             sqlQueryObject.addSelectField("nome_porta");
  1165.                             sqlQueryObject.setANDLogicOperator(true);
  1166.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta=?");
  1167.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  1168.                             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".tipo_soggetto=?");
  1169.                             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI+".nome_soggetto=?");
  1170.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".tipo_servizio=?");
  1171.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".servizio=?");
  1172.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".versione_servizio=?");
  1173.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".azione=?");
  1174.                             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".mode_azione=?");
  1175.                             queryString = sqlQueryObject.createSQLQuery();
  1176.                             stmt = con.prepareStatement(queryString);
  1177.                             index = 1;
  1178.                             stmt.setString(index++, mapping.getIdPortaApplicativa().getNome());
  1179.                             stmt.setString(index++, idServizio.getSoggettoErogatore().getTipo());
  1180.                             stmt.setString(index++, idServizio.getSoggettoErogatore().getNome());
  1181.                             stmt.setString(index++, idServizio.getTipo());
  1182.                             stmt.setString(index++, idServizio.getNome());
  1183.                             stmt.setInt(index++, idServizio.getVersione());
  1184.                             stmt.setString(index++, idOperazione.getNome());
  1185.                             stmt.setString(index++, ModalitaIdentificazioneAzione.STATIC.getValue());
  1186.                             risultato = stmt.executeQuery();
  1187.                             while (risultato.next()){
  1188.                                 String nome = risultato.getString("nome_porta");
  1189.                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nome, tipoDB, con, normalizeObjectIds);
  1190.                                 if(resultPorta.mapping) {
  1191.                                     urlInvocazionePAMappingList.add(resultPorta.label);
  1192.                                 }
  1193.                                 else {
  1194.                                     urlInvocazionePAList.add(resultPorta.label);
  1195.                                 }
  1196.                                 isInUso = true;
  1197.                             }
  1198.                             risultato.close();
  1199.                             stmt.close();
  1200.                             
  1201.                             
  1202.                             // ** Controllo che non sia associato a policy di controllo del traffico o allarmi **
  1203.                             
  1204.                             int max = 2;
  1205.                             if(!CostantiDB.isAllarmiEnabled()) {
  1206.                                 max=1;
  1207.                             }
  1208.                             for (int i = 0; i < max; i++) {
  1209.                                 
  1210.                                 String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  1211.                                 String identificativoColumn = "active_policy_id";
  1212.                                 String aliasColumn = "policy_alias";
  1213.                                 List<String> list = ctList;
  1214.                                 String oggetto = "Policy";
  1215.                                 if(i==1) {
  1216.                                     tabella = CostantiDB.ALLARMI;
  1217.                                     identificativoColumn = "nome";
  1218.                                     aliasColumn = "alias";
  1219.                                     list = allarmeList;
  1220.                                     oggetto = "Allarme";
  1221.                                 }
  1222.                             
  1223.                                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1224.                                 sqlQueryObject.addFromTable(tabella);
  1225.                                 sqlQueryObject.addSelectField(identificativoColumn);
  1226.                                 sqlQueryObject.addSelectField(aliasColumn);
  1227.                                 sqlQueryObject.addSelectField("filtro_ruolo");
  1228.                                 sqlQueryObject.addSelectField("filtro_porta");
  1229.                                 sqlQueryObject.setANDLogicOperator(true);
  1230.                                 sqlQueryObject.addWhereCondition(tabella+".filtro_ruolo=?");
  1231.                                 sqlQueryObject.addWhereCondition(tabella+".filtro_porta=?");
  1232.                                 
  1233.                                 // condizione di controllo
  1234.                                 sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1235.                                 sqlQueryObjectOr.setANDLogicOperator(false);
  1236.                                 // (filtro_azione == 'NOME') OR (filtro_azione like 'NOME,%') OR (filtro_azione like '%,NOME') OR (filtro_azione like '%,applicabilita_azioni,%')
  1237.                                 /** CLOB sqlQueryObjectOr.addWhereCondition(tabella+".filtro_azione = ?");*/
  1238.                                 sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idOperazione.getNome(), false , false);
  1239.                                 sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idOperazione.getNome()+",", LikeConfig.startsWith(false));
  1240.                                 sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idOperazione.getNome(), LikeConfig.endsWith(false));
  1241.                                 sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idOperazione.getNome()+",", true , false);
  1242.                                 sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  1243.                                 
  1244.                                 sqlQueryObject.addOrderBy("filtro_ruolo");
  1245.                                 sqlQueryObject.addOrderBy("filtro_porta");
  1246.                                 queryString = sqlQueryObject.createSQLQuery();
  1247.                                 stmt = con.prepareStatement(queryString);
  1248.                                 stmt.setString(1, "applicativa");
  1249.                                 stmt.setString(2, mapping.getIdPortaApplicativa().getNome());
  1250.                                 /** CLOB stmt.setString(3, idRisorsa.getNome());*/
  1251.                                 risultato = stmt.executeQuery();
  1252.                                 while (risultato.next()) {
  1253.                                     
  1254.                                     String alias = risultato.getString(aliasColumn);
  1255.                                     if(alias== null || "".equals(alias)) {
  1256.                                         alias = risultato.getString(identificativoColumn);
  1257.                                     }
  1258.                                     
  1259.                                     String nomePorta = risultato.getString("filtro_porta");
  1260.                                     String filtroRuolo = risultato.getString("filtro_ruolo");
  1261.                                     if(nomePorta!=null) {
  1262.                                         String tipo = null;
  1263.                                         String label = null;
  1264.                                         if("applicativa".equals(filtroRuolo)) {
  1265.                                             try {
  1266.                                                 ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  1267.                                                 if(resultPorta.mapping) {
  1268.                                                     label = "Erogazione di Servizio "+ resultPorta.label;
  1269.                                                 }
  1270.                                             }catch(Exception e) {
  1271.                                                 tipo = "Inbound";
  1272.                                             }
  1273.                                         }
  1274.                                         else {
  1275.                                             tipo = filtroRuolo;
  1276.                                         }
  1277.                                         if(label==null) {
  1278.                                             list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  1279.                                         }
  1280.                                         else {
  1281.                                             list.add(oggetto+" '"+alias+"' attiva nella "+label);
  1282.                                         }
  1283.                                     }
  1284.                                     else {
  1285.                                         list.add(oggetto+" '"+alias+"'");
  1286.                                     }
  1287.                     
  1288.                                     isInUso = true;
  1289.                                 }
  1290.                                 risultato.close();
  1291.                                 stmt.close();
  1292.                             }
  1293.                         }
  1294.                     }
  1295.                 }
  1296.             }
  1297.             
  1298.                         
  1299.             
  1300.             
  1301.             
  1302.             // ** Controllo che non sia associato a policy di controllo del traffico o allarmi generali **
  1303.             
  1304.             long idAccordoServizioParteComune = DBUtils.getIdAccordoServizioParteComune(idOperazione.getIdPortType().getIdAccordo(), con, tipoDB);
  1305.             if(idAccordoServizioParteComune<=0){
  1306.                 throw new UtilsException("Accordi di Servizio Parte Comune con id ["+idOperazione.getIdPortType().getIdAccordo().toString()+"] non trovato");
  1307.             }
  1308.             
  1309.             // Recupero servizi che implementano l'accordo
  1310.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1311.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1312.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1313.             sqlQueryObject.addSelectField("*");
  1314.             sqlQueryObject.addWhereCondition("id_accordo = ?");
  1315.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  1316.             sqlQueryObject.setANDLogicOperator(true);
  1317.             queryString = sqlQueryObject.createSQLQuery();
  1318.             stmt = con.prepareStatement(queryString);
  1319.             stmt.setLong(1, idAccordoServizioParteComune);
  1320.             risultato = stmt.executeQuery();
  1321.             List<IDServizio> listIDServizio = new ArrayList<>();
  1322.             while (risultato.next()){
  1323.                 String tipoSoggettoErogatore = risultato.getString("tipo_soggetto");
  1324.                 String nomeSoggettoErogatore = risultato.getString("nome_soggetto");
  1325.                 String tipoServizio = risultato.getString("tipo_servizio");
  1326.                 String nomeServizio = risultato.getString("nome_servizio");
  1327.                 int versioneServizio = risultato.getInt("versione_servizio");
  1328.                 IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipoServizio, nomeServizio, 
  1329.                         tipoSoggettoErogatore, nomeSoggettoErogatore, versioneServizio);
  1330.                 listIDServizio.add(idServizio);
  1331.             }
  1332.             risultato.close();
  1333.             stmt.close();
  1334.             
  1335.             if(!listIDServizio.isEmpty()) {
  1336.             
  1337.                 for (IDServizio idServizio : listIDServizio) {
  1338.             
  1339.                     int max = 2;
  1340.                     if(!CostantiDB.isAllarmiEnabled()) {
  1341.                         max=1;
  1342.                     }
  1343.                     for (int i = 0; i < max; i++) {
  1344.                         
  1345.                         String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  1346.                         String identificativoColumn = "active_policy_id";
  1347.                         String aliasColumn = "policy_alias";
  1348.                         List<String> list = ctList;
  1349.                         String oggetto = "Policy";
  1350.                         if(i==1) {
  1351.                             tabella = CostantiDB.ALLARMI;
  1352.                             identificativoColumn = "nome";
  1353.                             aliasColumn = "alias";
  1354.                             list = allarmeList;
  1355.                             oggetto = "Allarme";
  1356.                         }
  1357.                     
  1358.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1359.                         sqlQueryObject.addFromTable(tabella);
  1360.                         sqlQueryObject.setSelectDistinct(true);
  1361.                         sqlQueryObject.addSelectField(identificativoColumn);
  1362.                         sqlQueryObject.addSelectField(aliasColumn);
  1363.                         sqlQueryObject.addSelectField("filtro_ruolo");
  1364.                         sqlQueryObject.addSelectField("filtro_porta");
  1365.                         sqlQueryObject.setANDLogicOperator(true);
  1366.                         sqlQueryObject.addWhereIsNullCondition(tabella+".filtro_porta");
  1367.                         
  1368.                         ISQLQueryObject sqlQueryObjectServizioCompleto = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1369.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_tipo_erogatore=?");
  1370.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_nome_erogatore=?");
  1371.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_tipo_servizio=?");
  1372.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_nome_servizio=?");
  1373.                         sqlQueryObjectServizioCompleto.addWhereCondition(tabella+".filtro_versione_servizio=?");
  1374.                         
  1375.                         ISQLQueryObject sqlQueryObjectServizioParziale = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1376.                         sqlQueryObjectServizioParziale.addWhereIsNullCondition(tabella+".filtro_tipo_erogatore");
  1377.                         sqlQueryObjectServizioParziale.addWhereIsNullCondition(tabella+".filtro_nome_erogatore");
  1378.                         sqlQueryObjectServizioParziale.addWhereCondition(tabella+".filtro_tipo_servizio=?");
  1379.                         sqlQueryObjectServizioParziale.addWhereCondition(tabella+".filtro_nome_servizio=?");
  1380.                         sqlQueryObjectServizioParziale.addWhereCondition(tabella+".filtro_versione_servizio=?");
  1381.                         
  1382.                         sqlQueryObject.addWhereCondition(false,false, sqlQueryObjectServizioCompleto.createSQLConditions(), sqlQueryObjectServizioParziale.createSQLConditions());
  1383.                         
  1384.                         // condizione di controllo
  1385.                         sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1386.                         sqlQueryObjectOr.setANDLogicOperator(false);
  1387.                         // (filtro_azione == 'NOME') OR (filtro_azione like 'NOME,%') OR (filtro_azione like '%,NOME') OR (filtro_azione like '%,applicabilita_azioni,%')
  1388.                         /** CLOB sqlQueryObjectOr.addWhereCondition(tabella+".filtro_azione = ?");*/
  1389.                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idOperazione.getNome(), false , false);
  1390.                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", idOperazione.getNome()+",", LikeConfig.startsWith(false));
  1391.                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idOperazione.getNome(), LikeConfig.endsWith(false));
  1392.                         sqlQueryObjectOr.addWhereLikeCondition(tabella+".filtro_azione", ","+idOperazione.getNome()+",", true , false);
  1393.                         sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  1394.                         
  1395.                         sqlQueryObject.addOrderBy("filtro_ruolo");
  1396.                         sqlQueryObject.addOrderBy("filtro_porta");
  1397.                         queryString = sqlQueryObject.createSQLQuery();
  1398.                         stmt = con.prepareStatement(queryString);
  1399.                         index = 1;
  1400.                         stmt.setString(index++, idServizio.getSoggettoErogatore().getTipo());
  1401.                         stmt.setString(index++, idServizio.getSoggettoErogatore().getNome());
  1402.                         stmt.setString(index++, idServizio.getTipo());
  1403.                         stmt.setString(index++, idServizio.getNome());
  1404.                         stmt.setInt(index++, idServizio.getVersione());
  1405.                         stmt.setString(index++, idServizio.getTipo());
  1406.                         stmt.setString(index++, idServizio.getNome());
  1407.                         stmt.setInt(index++, idServizio.getVersione());
  1408.                         /** CLOB stmt.setString(index++, idRisorsa.getNome());*/
  1409.                         risultato = stmt.executeQuery();
  1410.                         while (risultato.next()) {
  1411.                             
  1412.                             String alias = risultato.getString(aliasColumn);
  1413.                             if(alias== null || "".equals(alias)) {
  1414.                                 alias = risultato.getString(identificativoColumn);
  1415.                             }
  1416.                             
  1417.                             String oggettoTrovato = oggetto+" '"+alias+"'";
  1418.                             if(!list.contains(oggettoTrovato)) {
  1419.                                 list.add(oggettoTrovato);
  1420.                             }
  1421.                                 
  1422.                             isInUso = true;
  1423.                         }
  1424.                         risultato.close();
  1425.                         stmt.close();
  1426.                     }
  1427.                 }
  1428.             }
  1429.             
  1430.             
  1431.             
  1432.             
  1433.             
  1434.             
  1435.             
  1436.             // ** Controllo che non sia riferito dalla configurazione SignalHub **
  1437.             if(registry && Costanti.MODIPA_PROTOCOL_NAME.equals(idOperazione.getIdPortType().getIdAccordo().getSoggettoReferente().getTipo()) &&
  1438.                 idServiziWithAccordo!=null && !idServiziWithAccordo.isEmpty()) {
  1439.                 for (IDServizio idServizio : idServiziWithAccordo) {
  1440.                                     
  1441.                     long idS = DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(),
  1442.                             idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(),
  1443.                             con, tipoDB);
  1444.                     if(idS<=0) {
  1445.                         throw new CoreException("Servizio '"+idServizio+"' non esistente");
  1446.                     }
  1447.                         
  1448.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  1449.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1450.                     sqlQueryObject.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  1451.                     sqlQueryObject.addSelectAliasField(CostantiDB.SERVIZI,"id","idServizio");
  1452.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI + ".id = ?");
  1453.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  1454.                     sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  1455.                     sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  1456.                     sqlQueryObject.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  1457.                     sqlQueryObject.setANDLogicOperator(true);
  1458.                     queryString = sqlQueryObject.createSQLQuery();
  1459.                     stmt = con.prepareStatement(queryString);
  1460.                     index = 1;
  1461.                     stmt.setLong(index++, idS);
  1462.                     stmt.setString(index++, ProprietariProtocolProperty.ACCORDO_SERVIZIO_PARTE_SPECIFICA.name());
  1463.                     stmt.setString(index++, Costanti.MODIPA_API_IMPL_INFO_SIGNAL_HUB_OPERATION_ID);
  1464.                     stmt.setString(index++, idOperazione.getNome());
  1465.                     risultato = stmt.executeQuery();
  1466.                     if(risultato.next()) {
  1467.                         
  1468.                         // trovata
  1469.                         IDPortaApplicativa idPA = DBMappingUtils.getIDPortaApplicativaAssociataDefault(idServizio, con, tipoDB);
  1470.                         if(idPA!=null) {
  1471.                             ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(idPA.getNome(), tipoDB, con, normalizeObjectIds);
  1472.                             modiSignalHubList.add(resultPorta.label);
  1473.                         }
  1474.                         else {
  1475.                             modiSignalHubList.add(idServizio.toString());
  1476.                         }
  1477.                         
  1478.                         isInUso = true;
  1479.                         
  1480.                     }
  1481.                 }
  1482.             }
  1483.             
  1484.             
  1485.             
  1486.             
  1487.             
  1488.             return isInUso;

  1490.         } catch (Exception se) {
  1491.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1492.         } finally {
  1493.             // Chiudo statement and resultset
  1494.             try {
  1495.                 if (risultato != null) {
  1496.                     risultato.close();
  1497.                 }
  1498.             } catch (Exception e) {
  1499.                 // ignore
  1500.             }
  1501.             try {
  1502.                 if (stmt != null) {
  1503.                     stmt.close();
  1504.                 }
  1505.             } catch (Exception e) {
  1506.                 // ignore
  1507.             }
  1508.         }
  1509.     }


  1512.     protected static String toString(IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  1513.         return toString(idOperazione, whereIsInUso, prefix, separator," non eliminabile perch&egrave; :");
  1514.     }
  1515.     protected static String toString(IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  1516.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  1517.         StringBuilder msgBuilder = new StringBuilder("Azione '"+idOperazione.getNome()+"'" + intestazione+separator);
  1518.         if(!prefix){
  1519.             msgBuilder = new StringBuilder("");
  1520.         }
  1521.         String separatorCategorie = "";
  1522.         if(whereIsInUso.size()>1) {
  1523.             separatorCategorie = separator;
  1524.         }
  1525.         for (ErrorsHandlerCostant key : keys) {
  1526.             List<String> messages = whereIsInUso.get(key);

  1528.             if ( messages!=null && !messages.isEmpty()) {
  1529.                 msgBuilder.append(separatorCategorie);
  1530.             }
  1531.             
  1532.             switch (key) {

  1534.             case IS_CORRELATA:
  1535.                 if ( messages!=null && !messages.isEmpty()) {
  1536.                     msgBuilder.append("correlata ad altre azioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1537.                 }
  1538.                 break;
  1539.             
  1540.             case IN_USO_IN_PORTE_APPLICATIVE:
  1541.                 if ( messages!=null && !messages.isEmpty()) {
  1542.                     msgBuilder.append("appartenente ad un gruppo differente da quello predefinito nelle Porte Inbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1543.                 }
  1544.                 break;
  1545.             case IN_USO_IN_PORTE_DELEGATE:
  1546.                 if ( messages!=null && !messages.isEmpty()) {
  1547.                     msgBuilder.append("appartenente ad un gruppo differente da quello predefinito nelle Porte Outbound: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1548.                 }
  1549.                 break;
  1550.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  1551.                 if ( messages!=null && !messages.isEmpty()) {
  1552.                     msgBuilder.append("appartenente ad un gruppo differente da quello predefinito nelle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1553.                 }
  1554.                 break;
  1555.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  1556.                 if ( messages!=null && !messages.isEmpty()) {
  1557.                     msgBuilder.append("appartenente ad un gruppo differente da quello predefinito nelle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1558.                 }
  1559.                 break;
  1560.                 
  1561.             case TRASFORMAZIONE_MAPPING_PD:
  1562.                 if ( messages!=null && !messages.isEmpty()) {
  1563.                     msgBuilder.append("utilizzata nel criterio di applicabilità della Trasformazione (Risorse) per le Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1564.                 }
  1565.                 break;
  1566.             case TRASFORMAZIONE_PD:
  1567.                 if ( messages!=null && !messages.isEmpty()) {
  1568.                     msgBuilder.append("utilizzata nelle Porte Outbound (Criterio di applicabilità della Trasformazione - Risorse): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1569.                 }
  1570.                 break;
  1571.             case TRASFORMAZIONE_MAPPING_PA:
  1572.                 if ( messages!=null && !messages.isEmpty()) {
  1573.                     msgBuilder.append("utilizzata nel criterio di applicabilità della Trasformazione (Risorse) per le Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1574.                 }
  1575.                 break;
  1576.             case TRASFORMAZIONE_PA:
  1577.                 if ( messages!=null && !messages.isEmpty()) {
  1578.                     msgBuilder.append("utilizzata nelle Porte Inbound (Criterio di applicabilità della Trasformazione - Risorse): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1579.                 }
  1580.                 break;
  1581.                 
  1582.             case URLINVOCAZIONE_MAPPING_PD:
  1583.                 if ( messages!=null && !messages.isEmpty()) {
  1584.                     msgBuilder.append("utilizzata nella configurazione dell'Url di Invocazione per le Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1585.                 }
  1586.                 break;
  1587.             case URLINVOCAZIONE_PD:
  1588.                 if ( messages!=null && !messages.isEmpty()) {
  1589.                     msgBuilder.append("utilizzata nelle Porte Outbound (Azione statica): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1590.                 }
  1591.                 break;
  1592.             case URLINVOCAZIONE_MAPPING_PA:
  1593.                 if ( messages!=null && !messages.isEmpty()) {
  1594.                     msgBuilder.append("utilizzata nella configurazione dell'Url di Invocazione per le Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1595.                 }
  1596.                 break;
  1597.             case URLINVOCAZIONE_PA:
  1598.                 if ( messages!=null && !messages.isEmpty()) {
  1599.                     msgBuilder.append("utilizzata nelle Porte Inbound (Azione statica): " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1600.                 }
  1601.                 break;
  1602.                 
  1603.             case CONTROLLO_TRAFFICO:
  1604.                 if ( messages!=null && !messages.isEmpty() ) {
  1605.                     msgBuilder.append("utilizzata in Policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1606.                 }
  1607.                 break;
  1608.             case ALLARMI:
  1609.                 if ( messages!=null && !messages.isEmpty() ) {
  1610.                     msgBuilder.append("utilizzato in Allarmi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1611.                 }
  1612.                 break;
  1613.                 
  1614.             case IS_RIFERITA_MODI_SIGNAL_HUB:
  1615.                 if ( messages!=null && !messages.isEmpty() ) {
  1616.                     msgBuilder.append("riferito nella configurazione 'SignalHub' dell'erogazione: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator);
  1617.                 }
  1618.                 break;              
  1619.                 
  1620.             default:
  1621.                 msgBuilder.append("utilizzata in oggetto non codificato ("+key+")"+separator);
  1622.                 break;
  1623.             }
  1624.             
  1625.         }// chiudo for

  1627.         return msgBuilder.toString();
  1628.     }
  1629.     
  1630. }
Created with JaCoCo 0.8.8.202204050719