DBOggettiInUsoUtils_accordi.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

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

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

  31. import org.openspcoop2.core.commons.DBUtils;
  32. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  33. import org.openspcoop2.core.constants.CostantiDB;
  34. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  35. import org.openspcoop2.core.id.IDAccordo;
  36. import org.openspcoop2.core.id.IDPortType;
  37. import org.openspcoop2.core.id.IDPortTypeAzione;
  38. import org.openspcoop2.core.id.IDServizio;
  39. import org.openspcoop2.core.id.IDSoggetto;
  40. import org.openspcoop2.core.mapping.DBMappingUtils;
  41. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  42. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  43. import org.openspcoop2.core.registry.constants.ServiceBinding;
  44. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  45. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  46. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  47. import org.openspcoop2.protocol.engine.constants.Costanti;
  48. import org.openspcoop2.utils.UtilsException;
  49. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  50. import org.openspcoop2.utils.sql.ISQLQueryObject;
  51. import org.openspcoop2.utils.sql.SQLObjectFactory;

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

  63.     protected static boolean isAccordoServizioParteComuneInUso(Connection con, String tipoDB, IDAccordo idAccordo, 
  64.             Map<ErrorsHandlerCostant,List<String>> whereIsInUso, boolean normalizeObjectIds) throws UtilsException {
  65.         String nomeMetodo = "isAccordoServizioParteComuneInUso";

  67.         PreparedStatement stmt = null;
  68.         ResultSet risultato = null;
  69.         String queryString;
  70.         try {
  71.             boolean isInUso = false;


  74.             long idAccordoServizioParteComune = DBUtils.getIdAccordoServizioParteComune(idAccordo, con, tipoDB);
  75.             if(idAccordoServizioParteComune<=0){
  76.                 throw new UtilsException("Accordi di Servizio Parte Comune con id ["+idAccordo.toString()+"] non trovato");
  77.             }

  79.             List<String> servizi_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_SERVIZI);
  80.             List<String> mappingErogazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  81.             List<String> mappingFruizionePD_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD);
  82.             
  83.             List<String> correlazione_list = whereIsInUso.get(ErrorsHandlerCostant.IS_CORRELATA);
  84.             
  85.             if (servizi_list == null) {
  86.                 servizi_list = new ArrayList<>();
  87.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_SERVIZI, servizi_list);
  88.             }
  89.             if (mappingErogazionePA_list == null) {
  90.                 mappingErogazionePA_list = new ArrayList<>();
  91.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePA_list);
  92.             }
  93.             if (mappingFruizionePD_list == null) {
  94.                 mappingFruizionePD_list = new ArrayList<>();
  95.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePD_list);
  96.             }
  97.             
  98.             if (correlazione_list == null) {
  99.                 correlazione_list = new ArrayList<>();
  100.                 whereIsInUso.put(ErrorsHandlerCostant.IS_CORRELATA, correlazione_list);
  101.             }
  102.             

  104.             //controllo se in uso in servizi
  105.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  106.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  107.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  108.             sqlQueryObject.addSelectField("*");
  109.             sqlQueryObject.addWhereCondition("id_accordo = ?");
  110.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  111.             sqlQueryObject.setANDLogicOperator(true);
  112.             queryString = sqlQueryObject.createSQLQuery();
  113.             stmt = con.prepareStatement(queryString);
  114.             stmt.setLong(1, idAccordoServizioParteComune);
  115.             risultato = stmt.executeQuery();
  116.             List<IDServizio> listIDServizio = new ArrayList<>();
  117.             while (risultato.next()){
  118.                 isInUso=true;
  119.                 
  120.                 String tipoSoggettoErogatore = risultato.getString("tipo_soggetto");
  121.                 String nomeSoggettoErogatore = risultato.getString("nome_soggetto");
  122.                 String tipoServizio = risultato.getString("tipo_servizio");
  123.                 String nomeServizio = risultato.getString("nome_servizio");
  124.                 int versioneServizio = risultato.getInt("versione_servizio");
  125.                 IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(tipoServizio, nomeServizio, 
  126.                         tipoSoggettoErogatore, nomeSoggettoErogatore, versioneServizio);
  127.                 listIDServizio.add(idServizio);
  128.             }
  129.             risultato.close();
  130.             stmt.close();
  131.             
  132.             if(!listIDServizio.isEmpty()) {
  133.                 
  134.                 for (IDServizio idServizio : listIDServizio) {
  135.                     
  136.                     String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idServizio.getSoggettoErogatore().getTipo());
  137.                     boolean found = false;
  138.                     
  139.                     // check PA
  140.                     List<MappingErogazionePortaApplicativa> listPA = null;
  141.                     try {
  142.                         listPA = DBMappingUtils.mappingErogazionePortaApplicativaList(con, tipoDB, idServizio, true);
  143.                     }catch(Exception e) {
  144.                         // ignore
  145.                     }
  146.                     if(listPA!=null && !listPA.isEmpty()) {
  147.                         found=true;
  148.                         for (MappingErogazionePortaApplicativa mappingPA : listPA) {
  149.                             String suffixGruppo = "";
  150.                             if(!mappingPA.isDefault()) {
  151.                                 suffixGruppo = " (Gruppo: "+mappingPA.getDescrizione()+")";
  152.                             }
  153.                             String servizio = DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+
  154.                                     NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, mappingPA.getIdServizio())+
  155.                                     suffixGruppo;
  156.                             mappingErogazionePA_list.add(servizio);
  157.                         }
  158.                     }
  159.                 
  160.                     // check PD
  161.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  162.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  163.                     sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  164.                     sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  165.                     sqlQueryObject.addSelectField("tipo_soggetto");
  166.                     sqlQueryObject.addSelectField("nome_soggetto");
  167.                     sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  168.                     sqlQueryObject.addWhereCondition("nome_servizio = ?");
  169.                     sqlQueryObject.addWhereCondition("versione_servizio = ?");
  170.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = ?");
  171.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_servizio = "+CostantiDB.SERVIZI+".id");
  172.                     sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  173.                     sqlQueryObject.setANDLogicOperator(true);
  174.                     queryString = sqlQueryObject.createSQLQuery();
  175.                     stmt = con.prepareStatement(queryString);
  176.                     stmt.setString(1, idServizio.getTipo());
  177.                     stmt.setString(2, idServizio.getNome());
  178.                     stmt.setInt(3, idServizio.getVersione());
  179.                     stmt.setLong(4, DBUtils.getIdSoggetto(idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(), con, tipoDB));
  180.                     risultato = stmt.executeQuery();
  181.                     while (risultato.next()){                   
  182.                         String tipoSoggettoFruitore = risultato.getString("tipo_soggetto");
  183.                         String nomeSoggettoFruitore = risultato.getString("nome_soggetto");
  184.                         IDSoggetto idSoggettoFruitore = new IDSoggetto(tipoSoggettoFruitore, nomeSoggettoFruitore);
  185.                         List<MappingFruizionePortaDelegata> listPD = null;
  186.                         try {
  187.                             listPD = DBMappingUtils.mappingFruizionePortaDelegataList(con, tipoDB, idSoggettoFruitore, idServizio, true);
  188.                         }catch(Exception e) {
  189.                             // ignore
  190.                         }
  191.                         if(listPD!=null && !listPD.isEmpty()) {
  192.                             found=true;
  193.                             for (MappingFruizionePortaDelegata mappingPD : listPD) {
  194.                                 String suffixGruppo = "";
  195.                                 if(!mappingPD.isDefault()) {
  196.                                     suffixGruppo = " (Gruppo: "+mappingPD.getDescrizione()+")";
  197.                                 }
  198.                                 String servizio = DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+
  199.                                         NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, mappingPD.getIdServizio())+
  200.                                         " (Fruitore:"+NamingUtils.getLabelSoggetto(protocollo, idSoggettoFruitore)+")"+
  201.                                         suffixGruppo;
  202.                                 mappingFruizionePD_list.add(servizio);
  203.                             }
  204.                         }
  205.                     }
  206.                     risultato.close();
  207.                     stmt.close();
  208.                     
  209.                     // servizio
  210.                     if(!found) {
  211.                         servizi_list.add(idServizio.toString());
  212.                     }
  213.                 }
  214.                 
  215.             }

  217.             
  218.             
  219.             
  220.             // Controllo che qualche azione o risorsa non sia stata correlata da un'altra azione tramite ModI
  221.             if(Costanti.MODIPA_PROTOCOL_NAME.equals(idAccordo.getSoggettoReferente().getTipo())) {
  222.             
  223.                 // Recupero tipo REST/SOAP
  224.                 
  225.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  226.                 sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  227.                 sqlQueryObject.addSelectField("service_binding");
  228.                 sqlQueryObject.addWhereCondition("id = ?");
  229.                 sqlQueryObject.setANDLogicOperator(true);
  230.                 queryString = sqlQueryObject.createSQLQuery();
  231.                 stmt = con.prepareStatement(queryString);
  232.                 stmt.setLong(1, idAccordoServizioParteComune);
  233.                 risultato = stmt.executeQuery();
  234.                 ServiceBinding tipoAccordo = null;
  235.                 if (risultato.next()){
  236.                     tipoAccordo = ServiceBinding.toEnumConstant(risultato.getString("service_binding"), false);
  237.                 }
  238.                 risultato.close();
  239.                 stmt.close();
  240.                 
  241.                 if(ServiceBinding.REST.equals(tipoAccordo)) {
  242.                     
  243.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  244.                     sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  245.                     sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES);
  246.                     sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"nome","nomeRisorsa");
  247.                     sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"http_method","httpMethodRisorsa");
  248.                     sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"path","pathRisorsa");
  249.                     sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI + ".id = ?");
  250.                     sqlQueryObject.addWhereCondition(CostantiDB.API_RESOURCES + ".id_accordo = " + CostantiDB.ACCORDI + ".id");
  251.                     sqlQueryObject.setANDLogicOperator(true);
  252.                     sqlQueryObject.addOrderBy("pathRisorsa");
  253.                     sqlQueryObject.addOrderBy("httpMethodRisorsa");
  254.                     queryString = sqlQueryObject.createSQLQuery();
  255.                     stmt = con.prepareStatement(queryString);
  256.                     int index = 1;
  257.                     stmt.setLong(index++, idAccordoServizioParteComune);
  258.                     risultato = stmt.executeQuery();
  259.                     List<String> risorse = new ArrayList<>();
  260.                     while(risultato.next()){
  261.                         String nomeRisorsa = risultato.getString("nomeRisorsa");
  262.                         risorse.add(nomeRisorsa);
  263.                     }
  264.                     risultato.close();
  265.                     stmt.close();
  266.                     
  267.                     if(!risorse.isEmpty()) {
  268.                         
  269.                         for (String nomeRisorsa : risorse) {
  270.                             
  271.                             ISQLQueryObject sqlQueryObjectApiExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  272.                             sqlQueryObjectApiExists.setANDLogicOperator(true);
  273.                             sqlQueryObjectApiExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  274.                             sqlQueryObjectApiExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  275.                             sqlQueryObjectApiExists.addWhereCondition(CostantiDB.API_RESOURCES + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  276.                             sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  277.                             sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  278.                             sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  279.                 
  280.                             ISQLQueryObject sqlQueryObjectOperationExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  281.                             sqlQueryObjectOperationExists.setANDLogicOperator(true);
  282.                             sqlQueryObjectOperationExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  283.                             sqlQueryObjectOperationExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  284.                             sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.API_RESOURCES + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  285.                             sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  286.                             sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  287.                             sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  288.                             
  289.                             
  290.                             // Verifico correlazione PUSH verso altri accordi
  291.                             
  292.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  293.                             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  294.                             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  295.                             sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES);
  296.                             sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"nome","nomeRisorsaCorrelata");
  297.                             sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"http_method","httpMethodRisorsaCorrelata");
  298.                             sqlQueryObject.addSelectAliasField(CostantiDB.API_RESOURCES,"path","pathRisorsaCorrelata");
  299.                             sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"nome","nomeApi");
  300.                             sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"versione","versioneApi");
  301.                             sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"tipo_soggetto","tipoReferenteApi");
  302.                             sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"nome_soggetto","nomeReferenteApi");
  303.                             sqlQueryObject.addWhereCondition(CostantiDB.API_RESOURCES + ".id_accordo = " + CostantiDB.ACCORDI + ".id");
  304.                             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI + ".id = " + CostantiDB.ACCORDI + ".id_referente");
  305.                             sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectApiExists);
  306.                             sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectOperationExists);
  307.                             sqlQueryObject.setANDLogicOperator(true);
  308.                             sqlQueryObject.addOrderBy("nomeApi");
  309.                             sqlQueryObject.addOrderBy("versioneApi");
  310.                             sqlQueryObject.addOrderBy("nomeReferenteApi");
  311.                             sqlQueryObject.addOrderBy("tipoReferenteApi");
  312.                             sqlQueryObject.addOrderBy("pathRisorsaCorrelata");
  313.                             sqlQueryObject.addOrderBy("httpMethodRisorsaCorrelata");
  314.                             sqlQueryObject.setSortType(true);
  315.                             queryString = sqlQueryObject.createSQLQuery();
  316.                             stmt = con.prepareStatement(queryString);
  317.                             index = 1;
  318.                             // sqlQueryObjectApiExists
  319.                             stmt.setString(index++, ProprietariProtocolProperty.RESOURCE.name());
  320.                             stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA);
  321.                             stmt.setString(index++, IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordo));
  322.                             // sqlQueryObjectOperationExists
  323.                             stmt.setString(index++, ProprietariProtocolProperty.RESOURCE.name());
  324.                             stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_AZIONE_RICHIESTA_CORRELATA);
  325.                             stmt.setString(index++, nomeRisorsa);
  326.                             risultato = stmt.executeQuery();
  327.                             IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  328.                             while (risultato.next()){
  329.                                 
  330.                                 String nomeApi = risultato.getString("nomeApi");
  331.                                 int versioneApi = risultato.getInt("versioneApi");
  332.                                 String tipoReferenteApi = risultato.getString("tipoReferenteApi");
  333.                                 String nomeReferenteApi = risultato.getString("nomeReferenteApi");
  334.                                 IDAccordo idAPI = idAccordoFactory.getIDAccordoFromValues(nomeApi, tipoReferenteApi, nomeReferenteApi, versioneApi);
  335.                                 
  336.                                 if(idAPI.equals(idAccordo)) {
  337.                                     continue; // non devo tenere traccia di correlazioni interne allo stesso accordo. Devo poter eliminare l'accordo nella sua interezza
  338.                                 }
  339.                                 
  340.                                 @SuppressWarnings("unused")
  341.                                 String nomeRisorsaCorrelata = risultato.getString("nomeRisorsaCorrelata");
  342.                                 String httpMethodRisorsaCorrelata = risultato.getString("httpMethodRisorsaCorrelata");
  343.                                 String pathRisorsaCorrelata = risultato.getString("pathRisorsaCorrelata");
  344.                                 
  345.                                 String path = null;
  346.                                 if(pathRisorsaCorrelata==null || "".equals(pathRisorsaCorrelata)) {
  347.                                     path = "*";
  348.                                 }
  349.                                 else {
  350.                                     path = pathRisorsaCorrelata;
  351.                                 }
  352.                                 
  353.                                 String method = null;
  354.                                 if(httpMethodRisorsaCorrelata==null || "".equals(httpMethodRisorsaCorrelata)) {
  355.                                     method = "Qualsiasi";
  356.                                 }
  357.                                 else {
  358.                                     method = httpMethodRisorsaCorrelata;
  359.                                 }
  360.                                 
  361.                                 correlazione_list.add("Risorsa "+method+" "+path+" dell'API '"+idAccordoFactory.getUriFromIDAccordo(idAPI)+"' (interazione: NonBloccante-Push)");
  362.                                 isInUso = true;
  363.                             }
  364.                             risultato.close();
  365.                             stmt.close();
  366.                         }
  367.                     }
  368.                 }
  369.                 else {
  370.                     
  371.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  372.                     sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  373.                     sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  374.                     sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  375.                     sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE_AZIONI,"nome","nomeAzione");
  376.                     sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE,"nome","nomePT");
  377.                     sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI + ".id = ?");
  378.                     sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE + ".id_accordo = " + CostantiDB.ACCORDI + ".id");
  379.                     sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id_port_type = " + CostantiDB.PORT_TYPE + ".id");
  380.                     sqlQueryObject.setANDLogicOperator(true);
  381.                     sqlQueryObject.addOrderBy("nomePT");
  382.                     sqlQueryObject.addOrderBy("nomeAzione");
  383.                     queryString = sqlQueryObject.createSQLQuery();
  384.                     stmt = con.prepareStatement(queryString);
  385.                     int index = 1;
  386.                     stmt.setLong(index++, idAccordoServizioParteComune);
  387.                     risultato = stmt.executeQuery();
  388.                     List<IDPortTypeAzione> azioni = new ArrayList<IDPortTypeAzione>();
  389.                     while(risultato.next()){
  390.                         
  391.                         IDPortType idPT = new IDPortType();
  392.                         idPT.setIdAccordo(idAccordo);
  393.                         idPT.setNome(risultato.getString("nomePT"));
  394.                         
  395.                         IDPortTypeAzione id = new IDPortTypeAzione();
  396.                         id.setIdPortType(idPT);
  397.                         id.setNome(risultato.getString("nomeAzione"));
  398.                         
  399.                         azioni.add(id);
  400.                     }
  401.                     risultato.close();
  402.                     stmt.close();
  403.                     
  404.                     if(!azioni.isEmpty()) {
  405.                         
  406.                         for (IDPortTypeAzione idAzione : azioni) {
  407.                             
  408.                             ISQLQueryObject sqlQueryObjectApiExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  409.                             sqlQueryObjectApiExists.setANDLogicOperator(true);
  410.                             sqlQueryObjectApiExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  411.                             sqlQueryObjectApiExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  412.                             sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  413.                             sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  414.                             sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  415.                             sqlQueryObjectApiExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  416.                             
  417.                             ISQLQueryObject sqlQueryObjectPortTypeExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  418.                             sqlQueryObjectPortTypeExists.setANDLogicOperator(true);
  419.                             sqlQueryObjectPortTypeExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  420.                             sqlQueryObjectPortTypeExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  421.                             sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  422.                             sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  423.                             sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  424.                             sqlQueryObjectPortTypeExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  425.                             
  426.                             ISQLQueryObject sqlQueryObjectOperationExists = SQLObjectFactory.createSQLQueryObject(tipoDB);
  427.                             sqlQueryObjectOperationExists.setANDLogicOperator(true);
  428.                             sqlQueryObjectOperationExists.addFromTable(CostantiDB.PROTOCOL_PROPERTIES);
  429.                             sqlQueryObjectOperationExists.addSelectField(CostantiDB.PROTOCOL_PROPERTIES, "name");
  430.                             sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id = " + CostantiDB.PROTOCOL_PROPERTIES + ".id_proprietario");
  431.                             sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".tipo_proprietario=?");
  432.                             sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".name=?");
  433.                             sqlQueryObjectOperationExists.addWhereCondition(CostantiDB.PROTOCOL_PROPERTIES + ".value_string=?");
  434.                             
  435.                             
  436.                             // Verifico correlazione PUSH verso altri accordi
  437.                             
  438.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  439.                             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  440.                             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  441.                             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  442.                             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  443.                             sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE_AZIONI,"nome","nomeAzioneCorrelata");
  444.                             sqlQueryObject.addSelectAliasField(CostantiDB.PORT_TYPE,"nome","nomePTCorrelato");
  445.                             sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"nome","nomeApi");
  446.                             sqlQueryObject.addSelectAliasField(CostantiDB.ACCORDI,"versione","versioneApi");
  447.                             sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"tipo_soggetto","tipoReferenteApi");
  448.                             sqlQueryObject.addSelectAliasField(CostantiDB.SOGGETTI,"nome_soggetto","nomeReferenteApi");
  449.                             sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE + ".id_accordo = " + CostantiDB.ACCORDI + ".id");
  450.                             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI + ".id = " + CostantiDB.ACCORDI + ".id_referente");
  451.                             sqlQueryObject.addWhereCondition(CostantiDB.PORT_TYPE_AZIONI + ".id_port_type = " + CostantiDB.PORT_TYPE + ".id");
  452.                             sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectApiExists);
  453.                             sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectPortTypeExists);
  454.                             sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectOperationExists);
  455.                             sqlQueryObject.setANDLogicOperator(true);
  456.                             sqlQueryObject.addOrderBy("nomeApi");
  457.                             sqlQueryObject.addOrderBy("versioneApi");
  458.                             sqlQueryObject.addOrderBy("nomeReferenteApi");
  459.                             sqlQueryObject.addOrderBy("tipoReferenteApi");
  460.                             sqlQueryObject.addOrderBy("nomePTCorrelato");
  461.                             sqlQueryObject.addOrderBy("nomeAzioneCorrelata");
  462.                             sqlQueryObject.setSortType(true);
  463.                             queryString = sqlQueryObject.createSQLQuery();
  464.                             stmt = con.prepareStatement(queryString);
  465.                             index = 1;
  466.                             // sqlQueryObjectApiExists
  467.                             stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  468.                             stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_API_RICHIESTA_CORRELATA);
  469.                             stmt.setString(index++, IDAccordoFactory.getInstance().getUriFromIDAccordo(idAzione.getIdPortType().getIdAccordo()));
  470.                             // sqlQueryObjectPortTypeExists
  471.                             stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  472.                             stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_SERVIZIO_RICHIESTA_CORRELATA);
  473.                             stmt.setString(index++, idAzione.getIdPortType().getNome());
  474.                             // sqlQueryObjectOperationExists
  475.                             stmt.setString(index++, ProprietariProtocolProperty.OPERATION.name());
  476.                             stmt.setString(index++, Costanti.MODIPA_PROFILO_INTERAZIONE_ASINCRONA_AZIONE_RICHIESTA_CORRELATA);
  477.                             stmt.setString(index++, idAzione.getNome());
  478.                             risultato = stmt.executeQuery();
  479.                             IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  480.                             while (risultato.next()){
  481.                                 String nomeAzioneCorrelata = risultato.getString("nomeAzioneCorrelata");
  482.                                 String nomePTCorrelato = risultato.getString("nomePTCorrelato");
  483.                                 String nomeApi = risultato.getString("nomeApi");
  484.                                 int versioneApi = risultato.getInt("versioneApi");
  485.                                 String tipoReferenteApi = risultato.getString("tipoReferenteApi");
  486.                                 String nomeReferenteApi = risultato.getString("nomeReferenteApi");
  487.                                 IDAccordo idAPI = idAccordoFactory.getIDAccordoFromValues(nomeApi, tipoReferenteApi, nomeReferenteApi, versioneApi);
  488.                                 
  489.                                 if(idAPI.equals(idAccordo)) {
  490.                                     continue; // non devo tenere traccia di correlazioni interne allo stesso accordo. Devo poter eliminare l'accordo nella sua interezza
  491.                                 }
  492.                                 
  493.                                 correlazione_list.add("Azione "+nomeAzioneCorrelata+" del Servizio "+nomePTCorrelato+" dell'API '"+idAccordoFactory.getUriFromIDAccordo(idAPI)+"' (interazione: NonBloccante-Push)");
  494.                                 isInUso = true;
  495.                             }
  496.                             risultato.close();
  497.                             stmt.close();
  498.                             
  499.                         }
  500.                         
  501.                     }
  502.                     
  503.                 }

  505.             }
  506.             
  507.             
  508.             return isInUso;

  510.         } catch (Exception se) {

  512.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  513.         } finally {
  514.             //Chiudo statement and resultset
  515.             JDBCUtilities.closeResources(risultato, stmt);
  516.         }
  517.     }


  520.     protected static String toString(IDAccordo idAccordo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, boolean normalizeObjectIds){

  522.         StringBuilder bf = new StringBuilder();
  523.         if(normalizeObjectIds && idAccordo.getSoggettoReferente()!=null) {
  524.             try {
  525.                 String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idAccordo.getSoggettoReferente().getTipo());
  526.                 String labelAccordo = DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteComune(protocollo, idAccordo);
  527.                 bf.append(labelAccordo);
  528.             }catch(Exception e) {
  529.                 bf.append(idAccordo.toString());
  530.             }
  531.         }
  532.         else {
  533.             bf.append(idAccordo.toString());
  534.         }

  536.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  537.         String msg = "API '"+bf.toString() + "' non eliminabile perch&egrave; :"+separator;
  538.         if(prefix==false){
  539.             msg = "";
  540.         }
  541.         String separatorCategorie = "";
  542.         if(whereIsInUso.size()>1) {
  543.             separatorCategorie = separator;
  544.         }
  545.         for (ErrorsHandlerCostant key : keys) {
  546.             List<String> messages = whereIsInUso.get(key);

  548.             if ( messages!=null && messages.size() > 0) {
  549.                 msg += separatorCategorie;
  550.             }
  551.             
  552.             switch (key) {
  553.             case IN_USO_IN_SERVIZI:
  554.                 if ( messages!=null && messages.size() > 0) {
  555.                     msg += "implementata dai Servizi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  556.                 }
  557.                 break;
  558.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  559.                 if ( messages!=null && messages.size() > 0) {
  560.                     msg += "implementata nelle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  561.                 }
  562.                 break;
  563.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  564.                 if ( messages!=null && messages.size() > 0) {
  565.                     msg += "implementata nelle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  566.                 }
  567.                 break;
  568.                 
  569.             case IS_CORRELATA:
  570.                 if ( messages!=null && messages.size() > 0) {
  571.                     msg += "correlata ad operazioni di altre API: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  572.                 }
  573.                 break;
  574.                 
  575.             default:
  576.                 msg += "utilizzata in oggetto non codificato ("+key+")"+separator;
  577.                 break;
  578.             }

  580.         }// chiudo for

  582.         return msg;
  583.     }
  584.     
  585. }
Created with JaCoCo 0.8.8.202204050719