DBOggettiInUsoUtils.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.  */


  22. package org.openspcoop2.protocol.engine.utils;

  24. import java.sql.Connection;
  25. import java.sql.PreparedStatement;
  26. import java.sql.ResultSet;
  27. import java.util.ArrayList;
  28. import java.util.HashMap;
  29. import java.util.List;
  30. import java.util.Map;

  32. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  33. import org.openspcoop2.core.config.CanaleConfigurazione;
  34. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  35. import org.openspcoop2.core.constants.CostantiDB;
  36. import org.openspcoop2.core.controllo_traffico.IdPolicy;
  37. import org.openspcoop2.core.id.IDAccordo;
  38. import org.openspcoop2.core.id.IDAccordoCooperazione;
  39. import org.openspcoop2.core.id.IDGenericProperties;
  40. import org.openspcoop2.core.id.IDGruppo;
  41. import org.openspcoop2.core.id.IDPortType;
  42. import org.openspcoop2.core.id.IDPortTypeAzione;
  43. import org.openspcoop2.core.id.IDPortaApplicativa;
  44. import org.openspcoop2.core.id.IDPortaDelegata;
  45. import org.openspcoop2.core.id.IDResource;
  46. import org.openspcoop2.core.id.IDRuolo;
  47. import org.openspcoop2.core.id.IDScope;
  48. import org.openspcoop2.core.id.IDServizio;
  49. import org.openspcoop2.core.id.IDServizioApplicativo;
  50. import org.openspcoop2.core.id.IDSoggetto;
  51. import org.openspcoop2.core.mapping.DBMappingUtils;
  52. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  53. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  54. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  55. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  56. import org.openspcoop2.protocol.engine.constants.Costanti;
  57. import org.openspcoop2.protocol.engine.constants.ModalitaIdentificazioneAzione;
  58. import org.openspcoop2.utils.UtilsException;
  59. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  60. import org.openspcoop2.utils.sql.ISQLQueryObject;
  61. import org.openspcoop2.utils.sql.SQLObjectFactory;

  63. /**
  64.  * DBOggettiInUsoUtils
  65.  * 
  66.  * @author Andrea Poli (apoli@link.it)
  67.  * @author $Author$
  68.  * @version $Rev$, $Date$
  69.  * 
  70.  */
  71. public class DBOggettiInUsoUtils  {

  73.     
  74.     protected static String getProtocolPrefix(String protocollo) throws UtilsException {
  75.         try {
  76.             return "["+NamingUtils.getLabelProtocollo(protocollo)+"] ";
  77.         } catch (Exception se) {
  78.             throw new UtilsException(se.getMessage(),se);
  79.         }
  80.     }
  81.     protected static String getSubjectSuffix(String protocollo, IDSoggetto idSoggetto)throws UtilsException {
  82.         try {
  83.             return " ("+NamingUtils.getLabelSoggetto(protocollo, idSoggetto)+")";
  84.         } catch (Exception se) {
  85.             throw new UtilsException(se.getMessage(),se);
  86.         }
  87.     }
  88.     public static String formatList(List<String> whereIsInUso, String separator) {
  89.         StringBuilder sb = new StringBuilder();
  90.         for (String v : whereIsInUso) {
  91.             sb.append(separator);
  92.             sb.append("- ");
  93.             sb.append(v);
  94.         }
  95.         return sb.toString();
  96.     }
  97.     protected static ResultPorta formatPortaDelegata(String nomePorta, String tipoDB, Connection con, boolean normalizeObjectIds) throws Exception {
  98.         
  99.         PreparedStatement stmt = null;
  100.         ResultSet risultato = null;
  101.         String queryString;

  103.         try {
  104.         
  105.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  106.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  107.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  108.             sqlQueryObject.addSelectField("tipo_soggetto");
  109.             sqlQueryObject.addSelectField("nome_soggetto");
  110.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  111.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".tipo_soggetto_erogatore");
  112.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_soggetto_erogatore");
  113.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".tipo_servizio");
  114.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_servizio");
  115.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".versione_servizio");
  116.             sqlQueryObject.setANDLogicOperator(true);
  117.             sqlQueryObject.setSelectDistinct(true);
  118.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".nome_porta = ?");
  119.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  120.             queryString = sqlQueryObject.createSQLQuery();
  121.             stmt = con.prepareStatement(queryString);
  122.             stmt.setString(1, nomePorta);
  123.             risultato = stmt.executeQuery();
  124.             if (risultato.next()) {
  125.                 String tipo_soggetto = risultato.getString("tipo_soggetto");
  126.                 String nome_soggetto = risultato.getString("nome_soggetto");
  127.                 String nome = risultato.getString("nome_porta");
  128.                 IDSoggetto idSoggetto = new IDSoggetto(tipo_soggetto, nome_soggetto);
  129.                 if(normalizeObjectIds) {
  130.                     
  131.                     String tipoSoggettoErogatore = risultato.getString("tipo_soggetto_erogatore");
  132.                     String nomeSoggettoErogatore = risultato.getString("nome_soggetto_erogatore");
  133.                     IDSoggetto idSoggettoErogatore = null;
  134.                     if(tipoSoggettoErogatore!=null && !"".equals(tipoSoggettoErogatore) &&
  135.                             nomeSoggettoErogatore!=null && !"".equals(nomeSoggettoErogatore)) {
  136.                         idSoggettoErogatore = new IDSoggetto(tipoSoggettoErogatore, nomeSoggettoErogatore);
  137.                     }
  138.                     
  139.                     String tipoServizio = risultato.getString("tipo_servizio");
  140.                     String nomeServizio = risultato.getString("nome_servizio");
  141.                     Integer versioneServizio = risultato.getInt("versione_servizio");
  142.                     
  143.                     String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(tipo_soggetto);
  144.                     
  145.                     MappingFruizionePortaDelegata mappingPD = null;
  146.                     if(tipoServizio!=null && !"".equals(tipoServizio) && 
  147.                             nomeServizio!=null && !"".equals(nomeServizio) &&
  148.                                     versioneServizio!=null && versioneServizio>0) {
  149.                         IDPortaDelegata idPD = new IDPortaDelegata();
  150.                         idPD.setNome(nome);
  151.                         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipoServizio, nomeServizio, idSoggettoErogatore, versioneServizio);
  152.                         boolean existsMapping = DBMappingUtils.existsMappingFruizione(idServizio, idSoggetto, idPD, con, tipoDB);
  153.                         if(existsMapping) {
  154.                             mappingPD = DBMappingUtils.getMappingFruizione(idServizio, idSoggetto, idPD, con, tipoDB);
  155.                         }
  156.                     }
  157.                     if(mappingPD!=null) {
  158.                         String suffixGruppo = "";
  159.                         if(!mappingPD.isDefault()) {
  160.                             suffixGruppo = " (Gruppo: "+mappingPD.getDescrizione()+")";
  161.                         }
  162.                         ResultPorta result = new ResultPorta();
  163.                         result.label=getProtocolPrefix(protocollo)+
  164.                                 NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, mappingPD.getIdServizio())+
  165.                                 " (Fruitore:"+NamingUtils.getLabelSoggetto(protocollo, idSoggetto)+")"+
  166.                                 suffixGruppo;
  167.                         result.mapping=true;
  168.                         return result;
  169.                     }
  170.                     else {
  171.                         ResultPorta result = new ResultPorta();
  172.                         result.label=getProtocolPrefix(protocollo)+nome+getSubjectSuffix(protocollo, idSoggetto);
  173.                         return result;
  174.                     }
  175.                 }
  176.                 else {
  177.                     ResultPorta result = new ResultPorta();
  178.                     result.label=tipo_soggetto + "/" + nome_soggetto+"_"+nome;
  179.                     return result;
  180.                 }
  181.                 
  182.             }
  183.             
  184.             throw new Exception("Porta Delegata '"+nomePorta+"' not found");
  185.             
  186.         } finally {
  187.             // Chiudo statement and resultset
  188.             JDBCUtilities.closeResources(risultato, stmt);
  189.         }
  190.     }
  191.     protected static ResultPorta formatPortaApplicativa(String nomePorta, String tipoDB, Connection con, boolean normalizeObjectIds) throws Exception {
  192.         PreparedStatement stmt = null;
  193.         ResultSet risultato = null;
  194.         String queryString;

  196.         try {
  197.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  198.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  199.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  200.             sqlQueryObject.addSelectField("tipo_soggetto");
  201.             sqlQueryObject.addSelectField("nome_soggetto");
  202.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  203.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".tipo_servizio");
  204.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".servizio");
  205.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".versione_servizio");
  206.             sqlQueryObject.setANDLogicOperator(true);
  207.             sqlQueryObject.setSelectDistinct(true);
  208.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".nome_porta = ?");
  209.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  210.             queryString = sqlQueryObject.createSQLQuery();
  211.             stmt = con.prepareStatement(queryString);
  212.             stmt.setString(1, nomePorta);
  213.             risultato = stmt.executeQuery();
  214.             if (risultato.next()) {
  215.                 String tipo_soggetto = risultato.getString("tipo_soggetto");
  216.                 String nome_soggetto = risultato.getString("nome_soggetto");
  217.                 String nome = risultato.getString("nome_porta");
  218.                 IDSoggetto idSoggetto = new IDSoggetto(tipo_soggetto, nome_soggetto);
  219.                 if(normalizeObjectIds) {
  220.                     
  221.                     String tipoServizio = risultato.getString("tipo_servizio");
  222.                     String nomeServizio = risultato.getString("servizio");
  223.                     Integer versioneServizio = risultato.getInt("versione_servizio");
  224.                     
  225.                     String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(tipo_soggetto);
  226.                     
  227.                     MappingErogazionePortaApplicativa mappingPA = null;
  228.                     if(tipoServizio!=null && !"".equals(tipoServizio) && 
  229.                             nomeServizio!=null && !"".equals(nomeServizio) &&
  230.                                     versioneServizio!=null && versioneServizio>0) {
  231.                         IDPortaApplicativa idPA = new IDPortaApplicativa();
  232.                         idPA.setNome(nome);
  233.                         IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipoServizio, nomeServizio, idSoggetto, versioneServizio);
  234.                         boolean existsMapping = DBMappingUtils.existsMappingErogazione(idServizio, idPA, con, tipoDB);
  235.                         if(existsMapping) {
  236.                             mappingPA = DBMappingUtils.getMappingErogazione(idServizio, idPA, con, tipoDB);
  237.                         }
  238.                     }
  239.                     if(mappingPA!=null) {
  240.                         String suffixGruppo = "";
  241.                         if(!mappingPA.isDefault()) {
  242.                             suffixGruppo = " (Gruppo: "+mappingPA.getDescrizione()+")";
  243.                         }
  244.                         ResultPorta result = new ResultPorta();
  245.                         result.label=getProtocolPrefix(protocollo)+
  246.                                 NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, mappingPA.getIdServizio())+
  247.                                 suffixGruppo;
  248.                         result.mapping = true;
  249.                         result.erogazioneModi = Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo);
  250.                         return result;
  251.                     }
  252.                     else {
  253.                         ResultPorta result = new ResultPorta();
  254.                         result.label=getProtocolPrefix(protocollo)+nome+getSubjectSuffix(protocollo, idSoggetto);
  255.                         result.erogazioneModi = Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo);
  256.                         return result;
  257.                     }
  258.                     
  259.                 }
  260.                 else {
  261.                     ResultPorta result = new ResultPorta();
  262.                     result.label=tipo_soggetto + "/" + nome_soggetto+"_"+nome;
  263.                     
  264.                     if(tipo_soggetto!=null) {
  265.                         String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(tipo_soggetto);
  266.                         result.erogazioneModi = Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo);
  267.                     }
  268.                     
  269.                     return result;
  270.                 }
  271.                 
  272.             }
  273.             
  274.             throw new Exception("Porta Delegata '"+nomePorta+"' not found");
  275.             
  276.         } finally {
  277.             // Chiudo statement and resultset
  278.             JDBCUtilities.closeResources(risultato, stmt);
  279.         }
  280.     }

  282.     public static void formatConnettori(List<Long> idConnettori,Map<ErrorsHandlerCostant, List<String>> whereIsInUso, 
  283.             Connection con, boolean normalizeObjectIds, String tipoDB) throws Exception {
  284.         if(idConnettori!=null && !idConnettori.isEmpty()) {
  285.             
  286.             List<String> connettorePA_list = whereIsInUso.get(ErrorsHandlerCostant.CONNETTORE_PA);
  287.             List<String> connettorePD_list = whereIsInUso.get(ErrorsHandlerCostant.CONNETTORE_PD);
  288.             List<String> mapping_connettorePA_list = whereIsInUso.get(ErrorsHandlerCostant.CONNETTORE_MAPPING_PA);
  289.             List<String> mapping_connettorePD_list = whereIsInUso.get(ErrorsHandlerCostant.CONNETTORE_MAPPING_PD);
  290.             
  291.             if (connettorePA_list == null) {
  292.                 connettorePA_list = new ArrayList<>();
  293.                 whereIsInUso.put(ErrorsHandlerCostant.CONNETTORE_PA, connettorePA_list);
  294.             }
  295.             if (connettorePD_list == null) {
  296.                 connettorePD_list = new ArrayList<>();
  297.                 whereIsInUso.put(ErrorsHandlerCostant.CONNETTORE_PD, connettorePD_list);
  298.             }
  299.             
  300.             if (mapping_connettorePA_list == null) {
  301.                 mapping_connettorePA_list = new ArrayList<>();
  302.                 whereIsInUso.put(ErrorsHandlerCostant.CONNETTORE_MAPPING_PA, mapping_connettorePA_list);
  303.             }
  304.             if (mapping_connettorePD_list == null) {
  305.                 mapping_connettorePD_list = new ArrayList<>();
  306.                 whereIsInUso.put(ErrorsHandlerCostant.CONNETTORE_MAPPING_PD, mapping_connettorePD_list);
  307.             }
  308.             
  309.             List<Long> idFruizioniDefault = new ArrayList<>();
  310.             
  311.             List<Long> idFruizioniGruppi_idFruizione = new ArrayList<>();
  312.             List<Long> idFruizioniGruppi_id = new ArrayList<>();
  313.             Map<Long,List<String>> idFruizioniGruppi_azioni = new HashMap<Long, List<String>>();
  314.             
  315.             List<Long> idServiziApplicativi = new ArrayList<>();
  316.             List<String> idServiziApplicativi_server = new ArrayList<>();
  317.             List<String> idServiziApplicativi_nome = new ArrayList<>();
  318.             
  319.             PreparedStatement stmt = null;
  320.             ResultSet risultato = null;
  321.             String queryString;

  323.             try {
  324.                                 
  325.                 for (Long idConnettore : idConnettori) {
  326.                     
  327.                     
  328.                     // Controllo che il connettore non sia in uso nelle porte applicative sia di default che dei gruppi
  329.                     
  330.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  331.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_APPLICATIVI);
  332.                     sqlQueryObject.addSelectField("id");
  333.                     sqlQueryObject.addSelectField("tipo");
  334.                     sqlQueryObject.addSelectField("nome");
  335.                     sqlQueryObject.setANDLogicOperator(true);
  336.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_APPLICATIVI+".id_connettore_inv=?");
  337.                     queryString = sqlQueryObject.createSQLQuery();
  338.                     stmt = con.prepareStatement(queryString);
  339.                     stmt.setLong(1, idConnettore);
  340.                     risultato = stmt.executeQuery();
  341.                     while (risultato.next()) {
  342.                         Long id = risultato.getLong("id");
  343.                         String tipo = risultato.getString("tipo");
  344.                         String nome = risultato.getString("nome");
  345.                         idServiziApplicativi.add(id);
  346.                         idServiziApplicativi_server.add(tipo);
  347.                         idServiziApplicativi_nome.add(nome);
  348.                     }
  349.                     risultato.close();
  350.                     stmt.close();
  351.                     
  352.                     
  353.                     // Controllo che il connettore non sia in uso nelle porte delegate di default
  354.                     
  355.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  356.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  357.                     sqlQueryObject.addSelectField("id");
  358.                     sqlQueryObject.setANDLogicOperator(true);
  359.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_connettore=?");
  360.                     queryString = sqlQueryObject.createSQLQuery();
  361.                     stmt = con.prepareStatement(queryString);
  362.                     stmt.setLong(1, idConnettore);
  363.                     risultato = stmt.executeQuery();
  364.                     while (risultato.next()) {
  365.                         Long id = risultato.getLong("id");
  366.                         idFruizioniDefault.add(id);
  367.                     }
  368.                     risultato.close();
  369.                     stmt.close();
  370.                     
  371.                     
  372.                     // Controllo che il connettore non sia in uso nelle porte delegate associate ai gruppi
  373.                     
  374.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  375.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  376.                     sqlQueryObject.addSelectField("id_fruizione");
  377.                     sqlQueryObject.addSelectField("id");
  378.                     sqlQueryObject.setANDLogicOperator(true);
  379.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI_AZIONI+".id_connettore=?");
  380.                     queryString = sqlQueryObject.createSQLQuery();
  381.                     stmt = con.prepareStatement(queryString);
  382.                     stmt.setLong(1, idConnettore);
  383.                     risultato = stmt.executeQuery();
  384.                     while (risultato.next()) {
  385.                         Long idF = risultato.getLong("id_fruizione");
  386.                         idFruizioniGruppi_idFruizione.add(idF);
  387.                         
  388.                         Long id = risultato.getLong("id");
  389.                         idFruizioniGruppi_id.add(id);
  390.                     }
  391.                     risultato.close();
  392.                     stmt.close();
  393.                     
  394.                     if(!idFruizioniGruppi_id.isEmpty()) {
  395.                         for (int i = 0; i < idFruizioniGruppi_id.size(); i++) {
  396.                             
  397.                             Long id = idFruizioniGruppi_id.get(0);
  398.                             Long idF = idFruizioniGruppi_idFruizione.get(0);
  399.                             
  400.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  401.                             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONE);
  402.                             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI_AZIONI);
  403.                             sqlQueryObject.addSelectField("nome_azione");
  404.                             sqlQueryObject.setANDLogicOperator(true);
  405.                             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI_AZIONI+".id=?");
  406.                             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI_AZIONE+".id_fruizione_azioni="+CostantiDB.SERVIZI_FRUITORI_AZIONI+".id");
  407.                             queryString = sqlQueryObject.createSQLQuery();
  408.                             stmt = con.prepareStatement(queryString);
  409.                             stmt.setLong(1, id);
  410.                             risultato = stmt.executeQuery();
  411.                             List<String> azioni = new ArrayList<>();
  412.                             while (risultato.next()) {
  413.                                 String nomeAzione = risultato.getString("nome_azione");
  414.                                 azioni.add(nomeAzione);
  415.                             }
  416.                             risultato.close();
  417.                             stmt.close();
  418.                             
  419.                             idFruizioniGruppi_azioni.put(idF, azioni);
  420.                         }
  421.                     }
  422.                     
  423.                 }
  424.                 
  425.                 
  426.                 
  427.                 // Se ho rilevato che il connettore è in uso nelle porte applicative (sia di default che dei gruppi) traduco questa informazione
  428.                 
  429.                 if(idServiziApplicativi!=null && !idServiziApplicativi.isEmpty()) {
  430.                     for (int i = 0; i < idServiziApplicativi.size(); i++) {
  431.                         Long idServiziApplicativo = idServiziApplicativi.get(i);
  432.                         String suffix = "";
  433.                         String tipoApplicativo = idServiziApplicativi_server.get(i);
  434.                         if(CostantiConfigurazione.SERVER.equals(tipoApplicativo)) {
  435.                             suffix = " (Applicativo Server: "+idServiziApplicativi_nome.get(i)+")";
  436.                         }
  437.                         
  438.                         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  439.                         sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE_SA);
  440.                         sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  441.                         sqlQueryObject.setSelectDistinct(true);
  442.                         sqlQueryObject.addSelectField("nome_porta");
  443.                         sqlQueryObject.addSelectField("connettore_nome");
  444.                         sqlQueryObject.setANDLogicOperator(true);
  445.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE_SA+".id_servizio_applicativo=?");
  446.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id="+CostantiDB.PORTE_APPLICATIVE_SA+".id_porta");
  447.                         queryString = sqlQueryObject.createSQLQuery();
  448.                         stmt = con.prepareStatement(queryString);
  449.                         stmt.setLong(1, idServiziApplicativo);
  450.                         risultato = stmt.executeQuery();
  451.                         while (risultato.next()) {
  452.                             String nomePorta = risultato.getString("nome_porta");
  453.                             
  454.                             String nomeConnettore = risultato.getString("connettore_nome");
  455.                             String labelNomeConnettore = "";
  456.                             if(nomeConnettore!=null && !"".equals(nomeConnettore)) {
  457.                                 labelNomeConnettore = " (Connettore: "+nomeConnettore+")";
  458.                             }
  459.                             
  460.                             ResultPorta resultPorta = formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  461.                             if(resultPorta.mapping) {
  462.                                 mapping_connettorePA_list.add(resultPorta.label+labelNomeConnettore+suffix);
  463.                             }
  464.                             else {
  465.                                 connettorePA_list.add(resultPorta.label+labelNomeConnettore+suffix);
  466.                             }
  467.                         }
  468.                         risultato.close();
  469.                         stmt.close();
  470.                         
  471.                     }
  472.                 }
  473.                 
  474.                 
  475.                 
  476.                 // Se ho rilevato che il connettore è in uso nelle porte delegate di default traduco questa informazione
  477.                 
  478.                 if(idFruizioniDefault!=null && !idFruizioniDefault.isEmpty()) {
  479.                     
  480.                     for (Long idFruizione : idFruizioniDefault) {
  481.                         
  482.                         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  483.                         sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  484.                         sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  485.                         sqlQueryObject.setSelectDistinct(true);
  486.                         sqlQueryObject.addSelectField("nome_porta");
  487.                         sqlQueryObject.setANDLogicOperator(true);
  488.                         sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_fruizione=?");
  489.                         sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  490.                         sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".is_default=?");
  491.                         queryString = sqlQueryObject.createSQLQuery();
  492.                         stmt = con.prepareStatement(queryString);
  493.                         stmt.setLong(1, idFruizione);
  494.                         stmt.setInt(2, CostantiDB.TRUE);
  495.                         risultato = stmt.executeQuery();
  496.                         while (risultato.next()) {
  497.                             String nomePorta = risultato.getString("nome_porta");
  498.                             ResultPorta resultPorta = formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  499.                             if(resultPorta.mapping) {
  500.                                 mapping_connettorePD_list.add(resultPorta.label);
  501.                             }
  502.                             else {
  503.                                 connettorePD_list.add(resultPorta.label);
  504.                             }
  505.                         }
  506.                         risultato.close();
  507.                         stmt.close();
  508.                         
  509.                     }
  510.                     
  511.                 }
  512.             
  513.                 
  514.                 
  515.                 // Se ho rilevato che il token è in uso nelle porte delegate di qualche gruppo traduco questa informazione
  516.                 
  517.                 if(idFruizioniGruppi_idFruizione!=null && !idFruizioniGruppi_idFruizione.isEmpty()) {
  518.                     
  519.                     for (Long idFruizione : idFruizioniGruppi_idFruizione) {
  520.                         
  521.                         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  522.                         sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  523.                         sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  524.                         sqlQueryObject.setSelectDistinct(true);
  525.                         sqlQueryObject.addSelectField("nome_porta");
  526.                         sqlQueryObject.setANDLogicOperator(true);
  527.                         sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_fruizione=?");
  528.                         sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  529.                         sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".is_default=?");
  530.                         sqlQueryObject.addWhereCondition(CostantiDB.PORTE_DELEGATE+".mode_azione=?");
  531.                         
  532.                         List<String> azioni = idFruizioniGruppi_azioni.get(idFruizione);
  533.                         if(azioni!=null && !azioni.isEmpty()) {
  534.                             for (@SuppressWarnings("unused") String azione : azioni) {
  535.                                 ISQLQueryObject sqlQueryObjectAzione = SQLObjectFactory.createSQLQueryObject(tipoDB);
  536.                                 sqlQueryObjectAzione.addFromTable(CostantiDB.PORTE_DELEGATE_AZIONI);
  537.                                 sqlQueryObjectAzione.addSelectField(CostantiDB.PORTE_DELEGATE_AZIONI+".azione");
  538.                                 sqlQueryObjectAzione.setANDLogicOperator(true);
  539.                                 sqlQueryObjectAzione.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".id_porta="+CostantiDB.PORTE_DELEGATE+".id");
  540.                                 sqlQueryObjectAzione.addWhereCondition(CostantiDB.PORTE_DELEGATE_AZIONI+".azione=?");
  541.                                 sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectAzione);
  542.                             }
  543.                         }
  544.                         
  545.                         queryString = sqlQueryObject.createSQLQuery();
  546.                         stmt = con.prepareStatement(queryString);
  547.                         int index = 1;
  548.                         stmt.setLong(index++, idFruizione);
  549.                         stmt.setInt(index++, CostantiDB.FALSE);
  550.                         stmt.setString(index++, ModalitaIdentificazioneAzione.DELEGATED_BY.getValue());
  551.                         if(azioni!=null && !azioni.isEmpty()) {
  552.                             for (String azione : azioni) {
  553.                                 stmt.setString(index++, azione);
  554.                             }
  555.                         }
  556.                         risultato = stmt.executeQuery();
  557.                         while (risultato.next()) {
  558.                             String nomePorta = risultato.getString("nome_porta");
  559.                             ResultPorta resultPorta = formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  560.                             if(resultPorta.mapping) {
  561.                                 mapping_connettorePD_list.add(resultPorta.label);
  562.                             }
  563.                             else {
  564.                                 connettorePD_list.add(resultPorta.label);
  565.                             }
  566.                         }
  567.                         risultato.close();
  568.                         stmt.close();
  569.                         
  570.                     }
  571.                     
  572.                 }
  573.             }
  574.             finally {
  575.                 // Chiudo statement and resultset
  576.                 JDBCUtilities.closeResources(risultato, stmt);
  577.             }
  578.         }
  579.     }

  581.     public static String formatGenericProperties(String tipologia, String nome) {
  582.         
  583.         /*
  584.         String template = null;
  585.         if(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_VALIDATION.equals(tipologia)) {
  586.             template = "Token Policy Validazione [{0}]";
  587.         }
  588.         else if(CostantiConfigurazione.GENERIC_PROPERTIES_TOKEN_TIPOLOGIA_RETRIEVE.equals(tipologia)) {
  589.             template = "Token Policy Negoziazione [{0}]";
  590.         }
  591.         else {
  592.             template = "Attribute Authority [{0}]";
  593.         }
  594.         return MessageFormat.format(template, nome);
  595.         */
  596.         return nome;
  597.         
  598.     }
  599.     
  600.     
  601.     
  602.     
  603.     

  605.     // ***** PDD ******

  607.     public static boolean isPddInUso(Connection con, String tipoDB, String nomePdd, List<String> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  608.         return DBOggettiInUsoUtils_pdd.isPddInUso(con, tipoDB, nomePdd, whereIsInUso, normalizeObjectIds);
  609.     }

  611.     public static String toString(String nomePdd, List<String> whereIsInUso, boolean prefix, String separator){
  612.         return DBOggettiInUsoUtils_pdd.toString(nomePdd, whereIsInUso, prefix, separator);
  613.     }
  614.     
  615.     
  616.     
  617.     
  618.     // ***** GRUPPI ******

  620.     // Lascio i metodi se servissero in futuro
  621.     public static boolean isGruppoConfigInUso(Connection con, String tipoDB, IDGruppo idGruppo, Map<ErrorsHandlerCostant, 
  622.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  623.         return DBOggettiInUsoUtils_gruppi.isGruppoConfigInUso(con, tipoDB, idGruppo, whereIsInUso, normalizeObjectIds);
  624.     }
  625.     public static boolean isGruppoRegistryInUso(Connection con, String tipoDB, IDGruppo idGruppo, Map<ErrorsHandlerCostant, 
  626.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  627.         return DBOggettiInUsoUtils_gruppi.isGruppoRegistryInUso(con, tipoDB, idGruppo, whereIsInUso, normalizeObjectIds);
  628.     }
  629.     public static boolean isGruppoInUso(Connection con, String tipoDB, IDGruppo idGruppo, Map<ErrorsHandlerCostant, 
  630.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  631.         return DBOggettiInUsoUtils_gruppi.isGruppoInUso(con, tipoDB, idGruppo, whereIsInUso, normalizeObjectIds);
  632.     }


  635.     public static String toString(IDGruppo idGruppo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  636.         return DBOggettiInUsoUtils_gruppi.toString(idGruppo, whereIsInUso, prefix, separator);
  637.     }
  638.     public static String toString(IDGruppo idGruppo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  639.         return DBOggettiInUsoUtils_gruppi.toString(idGruppo, whereIsInUso, prefix, separator, intestazione);
  640.     }
  641.     
  642.     
  643.     
  644.     
  645.     // ***** RUOLI ******

  647.     public static boolean isRuoloConfigInUso(Connection con, String tipoDB, IDRuolo idRuolo, Map<ErrorsHandlerCostant, 
  648.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  649.         return DBOggettiInUsoUtils_ruoli.isRuoloConfigInUso(con, tipoDB, idRuolo, whereIsInUso, normalizeObjectIds);
  650.     }
  651.     public static boolean isRuoloRegistryInUso(Connection con, String tipoDB, IDRuolo idRuolo, Map<ErrorsHandlerCostant, 
  652.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  653.         return DBOggettiInUsoUtils_ruoli.isRuoloRegistryInUso(con, tipoDB, idRuolo, whereIsInUso, normalizeObjectIds);
  654.     }
  655.     public static boolean isRuoloInUso(Connection con, String tipoDB, IDRuolo idRuolo, Map<ErrorsHandlerCostant, 
  656.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  657.         return DBOggettiInUsoUtils_ruoli.isRuoloInUso(con, tipoDB, idRuolo, whereIsInUso, normalizeObjectIds);
  658.     }


  661.     public static String toString(IDRuolo idRuolo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  662.         return DBOggettiInUsoUtils_ruoli.toString(idRuolo, whereIsInUso, prefix, separator);
  663.     }
  664.     public static String toString(IDRuolo idRuolo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  665.         return DBOggettiInUsoUtils_ruoli.toString(idRuolo, whereIsInUso, prefix, separator, intestazione);
  666.     }
  667.     
  668.     
  669.     
  670.     
  671.     // ***** SCOPE ******

  673.     // Lascio i metodi se servissero in futuro
  674.     public static boolean isScopeConfigInUso(Connection con, String tipoDB, IDScope idScope, Map<ErrorsHandlerCostant, 
  675.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  676.         return DBOggettiInUsoUtils_scope.isScopeConfigInUso(con, tipoDB, idScope, whereIsInUso, normalizeObjectIds);
  677.     }
  678. //  public static boolean isScopeRegistryInUso(Connection con, String tipoDB, IDScope idScope, Map<ErrorsHandlerCostant, 
  679. //          List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  680. //      return DBOggettiInUsoUtils_scope.isScopeRegistryInUso(con, tipoDB, idScope, whereIsInUso, normalizeObjectIds);
  681. //  }
  682.     public static boolean isScopeInUso(Connection con, String tipoDB, IDScope idScope, Map<ErrorsHandlerCostant, 
  683.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  684.         return DBOggettiInUsoUtils_scope.isScopeInUso(con, tipoDB, idScope, whereIsInUso, normalizeObjectIds);
  685.     }


  688.     public static String toString(IDScope idScope, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  689.         return DBOggettiInUsoUtils_scope.toString(idScope, whereIsInUso, prefix, separator);
  690.     }
  691.     public static String toString(IDScope idScope, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  692.         return DBOggettiInUsoUtils_scope.toString(idScope, whereIsInUso, prefix, separator, intestazione);
  693.     }
  694.     
  695.     
  696.     
  697.     
  698.     // ***** SOGGETTI ******

  700.     public static boolean isSoggettoConfigInUso(Connection con, String tipoDB, IDSoggetto idSoggettoConfig, boolean checkControlloTraffico, 
  701.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds,
  702.             boolean verificaRuoli) throws UtilsException {
  703.         return DBOggettiInUsoUtils_soggetti.isSoggettoConfigInUso(con, tipoDB, idSoggettoConfig, checkControlloTraffico, whereIsInUso, normalizeObjectIds, verificaRuoli);
  704.     }
  705.     public static boolean isSoggettoRegistryInUso(Connection con, String tipoDB, IDSoggetto idSoggettoRegistro, boolean checkControlloTraffico, 
  706.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds,
  707.             boolean verificaRuoli) throws UtilsException {
  708.         return DBOggettiInUsoUtils_soggetti.isSoggettoRegistryInUso(con, tipoDB, idSoggettoRegistro, checkControlloTraffico, whereIsInUso, normalizeObjectIds, verificaRuoli);
  709.     }
  710.     
  711.     public static String toString(IDSoggetto idSoggetto, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, boolean normalizeObjectIds){
  712.         return DBOggettiInUsoUtils_soggetti.toString(idSoggetto, whereIsInUso, prefix, separator, normalizeObjectIds);
  713.     }
  714.     
  715.     
  716.     
  717.     
  718.     // ***** ACCORDI DI COOPERAZIONE ******

  720.     public static boolean isAccordoCooperazioneInUso(Connection con, String tipoDB, IDAccordoCooperazione idAccordo, 
  721.             Map<ErrorsHandlerCostant,List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  722.         return DBOggettiInUsoUtils_accordiCooperazione.isAccordoCooperazioneInUso(con, tipoDB, idAccordo, whereIsInUso, normalizeObjectIds);
  723.     }

  725.     public static String toString(IDAccordoCooperazione idAccordo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, boolean normalizeObjectIds){
  726.         return DBOggettiInUsoUtils_accordiCooperazione.toString(idAccordo, whereIsInUso, prefix, separator, normalizeObjectIds);
  727.     }
  728.     
  729.     
  730.     
  731.     
  732.     // ***** ACCORDI DI SERVIZIO PARTE COMUNE ******

  734.     public static boolean isAccordoServizioParteComuneInUso(Connection con, String tipoDB, IDAccordo idAccordo, 
  735.             Map<ErrorsHandlerCostant,List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  736.         return DBOggettiInUsoUtils_accordi.isAccordoServizioParteComuneInUso(con, tipoDB, idAccordo, whereIsInUso, normalizeObjectIds);
  737.     }

  739.     public static String toString(IDAccordo idAccordo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, boolean normalizeObjectIds){
  740.         return DBOggettiInUsoUtils_accordi.toString(idAccordo, whereIsInUso, prefix, separator, normalizeObjectIds);
  741.     }
  742.     
  743.     
  744.     
  745.     
  746.     // ***** RESOURCES ******

  748.     public static boolean isRisorsaConfigInUso(Connection con, String tipoDB, IDResource idRisorsa, Map<ErrorsHandlerCostant, 
  749.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  750.         return DBOggettiInUsoUtils_accordiRest.isRisorsaConfigInUso(con, tipoDB, idRisorsa, whereIsInUso, normalizeObjectIds);
  751.     }
  752.     public static boolean isRisorsaRegistryInUso(Connection con, String tipoDB, IDResource idRisorsa, Map<ErrorsHandlerCostant, 
  753.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  754.         return DBOggettiInUsoUtils_accordiRest.isRisorsaRegistryInUso(con, tipoDB, idRisorsa, whereIsInUso, normalizeObjectIds);
  755.     }
  756.     public static boolean isRisorsaInUso(Connection con, String tipoDB, IDResource idRisorsa, Map<ErrorsHandlerCostant, 
  757.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  758.         return DBOggettiInUsoUtils_accordiRest.isRisorsaInUso(con, tipoDB, idRisorsa, whereIsInUso, normalizeObjectIds);
  759.     }

  761.     public static String toString(IDResource idRisorsa, String methodPath, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  762.         return DBOggettiInUsoUtils_accordiRest.toString(idRisorsa, methodPath, whereIsInUso, prefix, separator);
  763.     }
  764.     public static String toString(IDResource idRisorsa, String methodPath, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  765.         return DBOggettiInUsoUtils_accordiRest.toString(idRisorsa, methodPath, whereIsInUso, prefix, separator, intestazione);
  766.     }
  767.     
  768.     
  769.     
  770.     
  771.     // ***** PORT TYPES ******

  773.     public static boolean isPortTypeConfigInUso(Connection con, String tipoDB, IDPortType idPT, Map<ErrorsHandlerCostant, 
  774.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  775.         return DBOggettiInUsoUtils_accordiSoap.isPortTypeConfigInUso(con, tipoDB, idPT, whereIsInUso, normalizeObjectIds);
  776.     }
  777.     public static boolean isPortTypeRegistryInUso(Connection con, String tipoDB, IDPortType idPT, Map<ErrorsHandlerCostant, 
  778.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  779.         return DBOggettiInUsoUtils_accordiSoap.isPortTypeRegistryInUso(con, tipoDB, idPT, whereIsInUso, normalizeObjectIds);
  780.     }
  781.     public static boolean isPortTypeInUso(Connection con, String tipoDB, IDPortType idPT, Map<ErrorsHandlerCostant, 
  782.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  783.         return DBOggettiInUsoUtils_accordiSoap.isPortTypeInUso(con, tipoDB, idPT, whereIsInUso, normalizeObjectIds);
  784.     }

  786.     public static String toString(IDPortType idPT, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  787.         return DBOggettiInUsoUtils_accordiSoap.toString(idPT, whereIsInUso, prefix, separator);
  788.     }
  789.     public static String toString(IDPortType idPT, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  790.         return DBOggettiInUsoUtils_accordiSoap.toString(idPT, whereIsInUso, prefix, separator, intestazione);
  791.     }
  792.     
  793.     
  794.     
  795.     
  796.     // ***** OPERATION ******

  798.     public static boolean isOperazioneConfigInUso(Connection con, String tipoDB, IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, 
  799.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  800.         return DBOggettiInUsoUtils_accordiSoap.isOperazioneConfigInUso(con, tipoDB, idOperazione, whereIsInUso, normalizeObjectIds);
  801.     }
  802.     public static boolean isOperazioneRegistryInUso(Connection con, String tipoDB, IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, 
  803.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  804.         return DBOggettiInUsoUtils_accordiSoap.isOperazioneRegistryInUso(con, tipoDB, idOperazione, whereIsInUso, normalizeObjectIds);
  805.     }
  806.     public static boolean isOperazioneInUso(Connection con, String tipoDB, IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, 
  807.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  808.         return DBOggettiInUsoUtils_accordiSoap.isOperazioneInUso(con, tipoDB, idOperazione, whereIsInUso, normalizeObjectIds);
  809.     }

  811.     public static String toString(IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  812.         return DBOggettiInUsoUtils_accordiSoap.toString(idOperazione, whereIsInUso, prefix, separator);
  813.     }
  814.     public static String toString(IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  815.         return DBOggettiInUsoUtils_accordiSoap.toString(idOperazione, whereIsInUso, prefix, separator, intestazione);
  816.     }
  817.     
  818.     
  819.     
  820.     
  821.     // ***** ACCORDI DI SERVIZIO PARTE SPECIFICA ******
  822.     
  823.     public static boolean isAccordoServizioParteSpecificaInUso(Connection con, String tipoDB, IDServizio idServizio, 
  824.             Map<ErrorsHandlerCostant,List<String>> whereIsInUso,
  825.             List<IDPortaDelegata> nomePDGenerateAutomaticamente, List<IDPortaApplicativa> nomePAGenerateAutomaticamente, boolean normalizeObjectIds) throws UtilsException {
  826.         return DBOggettiInUsoUtils_accordiParteSpecifica.isAccordoServizioParteSpecificaInUso(con, tipoDB, idServizio, whereIsInUso, 
  827.                 nomePDGenerateAutomaticamente, nomePAGenerateAutomaticamente, normalizeObjectIds);
  828.     }
  829.     public static String toString(IDServizio idServizio, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, 
  830.             boolean normalizeObjectIds, String oggetto){
  831.         return DBOggettiInUsoUtils_accordiParteSpecifica.toString(idServizio, whereIsInUso, prefix, separator, normalizeObjectIds, oggetto);
  832.     }
  833.     
  834.     
  835.     
  836.     
  837.     // ***** SERVIZI APPLICATIVI ******

  839.     public static boolean isServizioApplicativoInUso(Connection con, String tipoDB, IDServizioApplicativo idServizioApplicativo, 
  840.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean isRegistroServiziLocale, boolean normalizeObjectIds,
  841.             boolean verificaRuoli) throws UtilsException {
  842.         return DBOggettiInUsoUtils_serviziApplicativi.isServizioApplicativoInUso(con, tipoDB, idServizioApplicativo, whereIsInUso, 
  843.                 isRegistroServiziLocale, normalizeObjectIds, verificaRuoli);
  844.     }

  846.     public static String toString(IDServizioApplicativo idServizioApplicativo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, boolean normalizeObjectIds){
  847.         return DBOggettiInUsoUtils_serviziApplicativi.toString(idServizioApplicativo, whereIsInUso, prefix, separator, normalizeObjectIds);
  848.     }
  849.     
  850.     
  851.     
  852.     
  853.     // ***** GENERIC PROPERTIES ******

  855.     // Lascio i metodi se servissero in futuro
  856.     public static boolean isGenericPropertiesInUso(Connection con, String tipoDB, IDGenericProperties idGP, Map<ErrorsHandlerCostant, 
  857.             List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  858.         return DBOggettiInUsoUtils_genericProperties.isGenericPropertiesInUso(con, tipoDB, idGP, whereIsInUso, normalizeObjectIds);
  859.     }

  861.     public static String toString(IDGenericProperties idGP, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  862.         return DBOggettiInUsoUtils_genericProperties.toString(idGP, whereIsInUso, prefix, separator);
  863.     }
  864.     public static String toString(IDGenericProperties idGP, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  865.         return DBOggettiInUsoUtils_genericProperties.toString(idGP, whereIsInUso, prefix, separator, intestazione);
  866.     }
  867.     
  868.     
  869.     
  870.     
  871.     // ***** CANALE ******
  872.     
  873.     public static boolean isCanaleInUsoRegistro(Connection con, String tipoDB, CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  874.         return DBOggettiInUsoUtils_canali.isCanaleInUsoRegistro(con, tipoDB, canale, whereIsInUso, normalizeObjectIds);
  875.     }
  876.     public static boolean isCanaleInUso(Connection con, String tipoDB, CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  877.         return DBOggettiInUsoUtils_canali.isCanaleInUso(con, tipoDB, canale, whereIsInUso, normalizeObjectIds);
  878.     }
  879.     public static boolean isCanaleInUso(Connection con, String tipoDB, CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds, 
  880.             boolean registry, boolean config, boolean nodi) throws UtilsException {
  881.         return DBOggettiInUsoUtils_canali.isCanaleInUso(con, tipoDB, canale, whereIsInUso, normalizeObjectIds,
  882.              registry, config, nodi);
  883.     }

  885.     public static String toString(CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  886.         return DBOggettiInUsoUtils_canali.toString(canale, whereIsInUso, prefix, separator);
  887.     }
  888.     public static String toString(CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, String intestazione){
  889.         return DBOggettiInUsoUtils_canali.toString(canale, whereIsInUso, prefix, separator, intestazione);
  890.     }
  891.     
  892.     
  893.     
  894.     
  895.     // ***** RATE LIMITNG POLICY ******

  897.     public static boolean isRateLimitingPolicyInUso(Connection con, String tipoDB, IdPolicy idPolicy, 
  898.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  899.         return DBOggettiInUsoUtils_rateLimiting.isRateLimitingPolicyInUso(con, tipoDB, idPolicy, whereIsInUso, normalizeObjectIds);
  900.     }
  901.     
  902.     public static String toString(IdPolicy idPolicy, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  903.         return DBOggettiInUsoUtils_rateLimiting.toString(idPolicy, whereIsInUso, prefix, separator);
  904.     }
  905.     
  906.     
  907.     
  908.     
  909.     // ***** PLUGINS ******

  911.     public static boolean isPluginInUso(Connection con, String tipoDB, String className, String label, String tipoPlugin, String tipo, 
  912.             Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  913.         return DBOggettiInUsoUtils_plugins.isPluginInUso(con, tipoDB, className, label, tipoPlugin, tipo, whereIsInUso, normalizeObjectIds);
  914.     }

  916.     public static String toString(String className, String label, String tipoPlugin, String tipo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator){
  917.         return DBOggettiInUsoUtils_plugins.toString(className, label, tipoPlugin, tipo, whereIsInUso, prefix, separator);
  918.     }

  920. }

  922. class ResultPorta {
  923.     boolean mapping = false;
  924.     String label;
  925.     boolean erogazioneModi = false;
  926. }
Created with JaCoCo 0.8.8.202204050719