DBOggettiInUsoUtils_accordiParteSpecifica.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.sql.SQLException;
  27. import java.util.ArrayList;
  28. import java.util.List;
  29. import java.util.Map;
  30. import java.util.Set;

  32. import org.openspcoop2.core.commons.DBUtils;
  33. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  34. import org.openspcoop2.core.constants.CostantiDB;
  35. import org.openspcoop2.core.id.IDAccordo;
  36. import org.openspcoop2.core.id.IDPortaApplicativa;
  37. import org.openspcoop2.core.id.IDPortaDelegata;
  38. import org.openspcoop2.core.id.IDServizio;
  39. import org.openspcoop2.core.id.IDSoggetto;
  40. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  41. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  42. import org.openspcoop2.utils.UtilsException;
  43. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  44. import org.openspcoop2.utils.sql.ISQLQueryObject;
  45. import org.openspcoop2.utils.sql.SQLObjectFactory;

  47. /**
  48.  * DBOggettiInUsoUtils_accordiParteSpecifica
  49.  * 
  50.  * @author Andrea Poli (apoli@link.it)
  51.  * @author $Author$
  52.  * @version $Rev$, $Date$
  53.  * 
  54.  */
  55. public class DBOggettiInUsoUtils_accordiParteSpecifica {

  57.     private static boolean isAccordoServizioParteSpecificaInUso(Connection con, String tipoDB, long idAccordoServizioParteSpecifica, 
  58.             Map<ErrorsHandlerCostant,List<String>> whereIsInUso, String nomeMetodo,
  59.             List<IDPortaDelegata> nomePDGenerateAutomaticamente, List<IDPortaApplicativa> nomePAGenerateAutomaticamente, boolean normalizeObjectIds) throws UtilsException {
  60.         
  61.         PreparedStatement stmt = null;
  62.         ResultSet risultato = null;
  63.         PreparedStatement stmt2 = null;
  64.         ResultSet risultato2 = null;
  65.         String queryString;
  66.         try {
  67.             boolean isInUso = false;


  70.             List<String> porteApplicative_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE);
  71.             List<String> porteDelegate_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE);
  72.             List<String> fruitori_list = whereIsInUso.get(ErrorsHandlerCostant.POSSIEDE_FRUITORI);
  73.             List<String> servizioComponente_list = whereIsInUso.get(ErrorsHandlerCostant.IS_SERVIZIO_COMPONENTE_IN_ACCORDI);
  74.             List<String> mappingErogazionePA_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA);
  75.             List<String> mappingFruizionePD_list = whereIsInUso.get(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD);
  76.             List<String> utenti_list = whereIsInUso.get(ErrorsHandlerCostant.UTENTE);
  77.             List<String> ct_list = whereIsInUso.get(ErrorsHandlerCostant.CONTROLLO_TRAFFICO);
  78.             List<String> allarme_list = whereIsInUso.get(ErrorsHandlerCostant.ALLARMI);

  80.             if (porteApplicative_list == null) {
  81.                 porteApplicative_list = new ArrayList<>();
  82.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_APPLICATIVE, porteApplicative_list);
  83.             }
  84.             if (porteDelegate_list == null) {
  85.                 porteDelegate_list = new ArrayList<>();
  86.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_PORTE_DELEGATE, porteDelegate_list);
  87.             }
  88.             if (fruitori_list == null) {
  89.                 fruitori_list = new ArrayList<>();
  90.                 whereIsInUso.put(ErrorsHandlerCostant.POSSIEDE_FRUITORI, fruitori_list);
  91.             }
  92.             if (servizioComponente_list == null) {
  93.                 servizioComponente_list = new ArrayList<>();
  94.                 whereIsInUso.put(ErrorsHandlerCostant.IS_SERVIZIO_COMPONENTE_IN_ACCORDI, servizioComponente_list);
  95.             }
  96.             if (mappingErogazionePA_list == null) {
  97.                 mappingErogazionePA_list = new ArrayList<>();
  98.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_EROGAZIONE_PA, mappingErogazionePA_list);
  99.             }
  100.             if (mappingFruizionePD_list == null) {
  101.                 mappingFruizionePD_list = new ArrayList<>();
  102.                 whereIsInUso.put(ErrorsHandlerCostant.IN_USO_IN_MAPPING_FRUIZIONE_PD, mappingFruizionePD_list);
  103.             }
  104.             if (utenti_list == null) {
  105.                 utenti_list = new ArrayList<>();
  106.                 whereIsInUso.put(ErrorsHandlerCostant.UTENTE, utenti_list);
  107.             }
  108.             if (ct_list == null) {
  109.                 ct_list = new ArrayList<>();
  110.                 whereIsInUso.put(ErrorsHandlerCostant.CONTROLLO_TRAFFICO, ct_list);
  111.             }
  112.             if (allarme_list == null) {
  113.                 allarme_list = new ArrayList<>();
  114.                 whereIsInUso.put(ErrorsHandlerCostant.ALLARMI, allarme_list);
  115.             }

  117.             
  118.             
  119.             // Raccolgo Dati Servizio.
  120.             String tipoServizio = null;
  121.             String nomeServizio = null;
  122.             int versioneServizio;
  123.             String tipoSoggetto = null;
  124.             String nomeSoggetto = null;
  125.             long idSoggetto;
  126.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  127.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  128.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  129.             sqlQueryObject.addSelectField("*");
  130.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  131.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id=?");
  132.             sqlQueryObject.setANDLogicOperator(true);
  133.             queryString = sqlQueryObject.createSQLQuery();
  134.             stmt = con.prepareStatement(queryString);
  135.             int index = 1;
  136.             stmt.setLong(index++, idAccordoServizioParteSpecifica);
  137.             risultato = stmt.executeQuery();
  138.             if (risultato.next()) {
  139.                 tipoServizio = risultato.getString("tipo_servizio");
  140.                 nomeServizio = risultato.getString("nome_servizio");
  141.                 versioneServizio = risultato.getInt("versione_servizio");
  142.                 tipoSoggetto = risultato.getString("tipo_soggetto");
  143.                 nomeSoggetto = risultato.getString("nome_soggetto");
  144.                 versioneServizio = risultato.getInt("versione_servizio");
  145.             }
  146.             else{
  147.                 throw new UtilsException("Accordo con id ["+idAccordoServizioParteSpecifica+"] non trovato");
  148.             }
  149.             risultato.close();
  150.             stmt.close();
  151.             
  152.             idSoggetto = DBUtils.getIdSoggetto(nomeSoggetto, tipoSoggetto, con, tipoDB);
  153.             
  154.             
  155.             
  156.             
  157.             
  158.             // porte applicative
  159.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  160.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  161.             sqlQueryObject.addSelectField("*");
  162.             sqlQueryObject.addWhereCondition(false, "id_servizio = ?", "tipo_servizio = ? AND servizio = ? AND versione_servizio = ?");
  163.             sqlQueryObject.addWhereCondition(false, "id_soggetto = ?", "id_soggetto_virtuale = ?", "tipo_soggetto_virtuale = ? AND nome_soggetto_virtuale = ?");
  164.             sqlQueryObject.setANDLogicOperator(true);
  165.             queryString = sqlQueryObject.createSQLQuery();
  166.             stmt = con.prepareStatement(queryString);
  167.             index = 1;
  168.             stmt.setLong(index++, idAccordoServizioParteSpecifica);
  169.             stmt.setString(index++, tipoServizio);
  170.             stmt.setString(index++, nomeServizio);
  171.             stmt.setInt(index++, versioneServizio);
  172.             stmt.setLong(index++, idSoggetto);
  173.             stmt.setLong(index++, idSoggetto);
  174.             stmt.setString(index++, tipoSoggetto);
  175.             stmt.setString(index++, nomeSoggetto);
  176.             risultato = stmt.executeQuery();
  177.             while (risultato.next()) {
  178.                 
  179.                 String nomePorta = risultato.getString("nome_porta");
  180.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  181.                 idPA.setNome(nomePorta);
  182.                 if(nomePAGenerateAutomaticamente!=null && !nomePAGenerateAutomaticamente.contains(idPA)) {
  183.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  184.                     if(resultPorta.mapping) {
  185.                         mappingErogazionePA_list.add(resultPorta.label); // non dovrebbe mai entrare in questa caso essendo filtrato da nomePAGenerateAutomaticamente
  186.                     }
  187.                     else {
  188.                         porteApplicative_list.add(resultPorta.label);
  189.                     }
  190.                     isInUso=true;
  191.                 }
  192.             }
  193.             risultato.close();
  194.             stmt.close();
  195.             
  196.             
  197.             
  198.             
  199.             // porte delegate
  200.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  201.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  202.             sqlQueryObject.addSelectField("*");
  203.             sqlQueryObject.addWhereCondition(false, "id_servizio = ?", "tipo_servizio = ? AND nome_servizio = ? AND versione_servizio = ?");
  204.             sqlQueryObject.addWhereCondition(false, "id_soggetto_erogatore = ?", "tipo_soggetto_erogatore = ? AND nome_soggetto_erogatore = ?");
  205.             sqlQueryObject.setANDLogicOperator(true);
  206.             queryString = sqlQueryObject.createSQLQuery();
  207.             stmt = con.prepareStatement(queryString);
  208.             index = 1;
  209.             stmt.setLong(index++, idAccordoServizioParteSpecifica);
  210.             stmt.setString(index++, tipoServizio);
  211.             stmt.setString(index++, nomeServizio);
  212.             stmt.setInt(index++, versioneServizio);
  213.             stmt.setLong(index++, idSoggetto);
  214.             stmt.setString(index++, tipoSoggetto);
  215.             stmt.setString(index++, nomeSoggetto);
  216.             risultato = stmt.executeQuery();
  217.             while (risultato.next()) {          
  218.                 String nomePorta = risultato.getString("nome_porta");
  219.                 IDPortaDelegata idPD = new IDPortaDelegata();
  220.                 idPD.setNome(nomePorta);
  221.                 if(nomePDGenerateAutomaticamente!=null && !nomePDGenerateAutomaticamente.contains(idPD)) {
  222.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  223.                     if(resultPorta.mapping) {
  224.                         mappingFruizionePD_list.add(resultPorta.label);
  225.                     }
  226.                     else {
  227.                         porteDelegate_list.add(resultPorta.label);
  228.                     }
  229.                     isInUso=true;
  230.                 }
  231.             }
  232.             risultato.close();
  233.             stmt.close();
  234.             
  235.             
  236.             
  237.             
  238.             
  239.             // mapping erogazione pa 
  240.             
  241.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  242.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_EROGAZIONE_PA);
  243.             sqlQueryObject.addFromTable(CostantiDB.PORTE_APPLICATIVE);
  244.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  245.             sqlQueryObject.addSelectField("tipo_soggetto");
  246.             sqlQueryObject.addSelectField("nome_soggetto");
  247.             sqlQueryObject.addSelectField(CostantiDB.PORTE_APPLICATIVE+".nome_porta");
  248.             sqlQueryObject.setANDLogicOperator(true);
  249.             sqlQueryObject.setSelectDistinct(true);
  250.             sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_EROGAZIONE_PA+".id_erogazione = ?");
  251.             sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_EROGAZIONE_PA+".id_porta = "+CostantiDB.PORTE_APPLICATIVE+".id");
  252.             sqlQueryObject.addWhereCondition(CostantiDB.PORTE_APPLICATIVE+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  253.             queryString = sqlQueryObject.createSQLQuery();
  254.             stmt = con.prepareStatement(queryString);
  255.             stmt.setLong(1, idAccordoServizioParteSpecifica);
  256.             risultato = stmt.executeQuery();
  257.             while (risultato.next()) {
  258.                 //String tipo_soggetto = risultato.getString("tipo_soggetto");
  259.                 //String nome_soggetto = risultato.getString("nome_soggetto");
  260.                 String nomePorta = risultato.getString("nome_porta");
  261.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  262.                 idPA.setNome(nomePorta);
  263.                 if(nomePAGenerateAutomaticamente!=null && 
  264.                         !nomePAGenerateAutomaticamente.contains(idPA)){
  265.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  266.                     if(resultPorta.mapping) {
  267.                         String l = resultPorta.label;
  268.                         if(mappingErogazionePA_list.contains(l)==false) { 
  269.                             mappingErogazionePA_list.add(l);
  270.                         }
  271.                     }
  272.                     else {
  273.                         // ?? e' gia' un mapping
  274.                         String l = resultPorta.label;
  275.                         if(porteApplicative_list.contains(l)==false) { 
  276.                             porteApplicative_list.add(l);
  277.                         }
  278.                     }
  279.                     isInUso=true;
  280.                 }
  281.             }
  282.             risultato.close();
  283.             stmt.close();
  284.             
  285.             
  286.             
  287.             
  288.             
  289.             
  290.             
  291.             
  292.             
  293.             
  294.             // mapping fruizioni pd
  295.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  296.             sqlQueryObject.addFromTable(CostantiDB.MAPPING_FRUIZIONE_PD);
  297.             sqlQueryObject.addFromTable(CostantiDB.PORTE_DELEGATE);
  298.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  299.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  300.             sqlQueryObject.setSelectDistinct(true);
  301.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".tipo_soggetto");
  302.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".nome_soggetto");
  303.             sqlQueryObject.addSelectField(CostantiDB.PORTE_DELEGATE+".nome_porta");
  304.             sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI + ".id = " + CostantiDB.SERVIZI_FRUITORI + ".id_soggetto");
  305.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI + ".id_servizio = ?");
  306.             sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_fruizione = "+CostantiDB.SERVIZI_FRUITORI + ".id");
  307.             sqlQueryObject.addWhereCondition(CostantiDB.MAPPING_FRUIZIONE_PD+".id_porta = "+CostantiDB.PORTE_DELEGATE + ".id");
  308.             sqlQueryObject.setANDLogicOperator(true);
  309.             queryString = sqlQueryObject.createSQLQuery();
  310.             stmt = con.prepareStatement(queryString);
  311.             stmt.setLong(1, idAccordoServizioParteSpecifica);
  312.             risultato = stmt.executeQuery();
  313.             while (risultato.next()) {
  314.                 //String tipo_soggetto = risultato.getString("tipo_soggetto");
  315.                 //String nome_soggetto = risultato.getString("nome_soggetto");
  316.                 String nomePorta = risultato.getString("nome_porta");
  317.                 IDPortaDelegata idPD = new IDPortaDelegata();
  318.                 idPD.setNome(nomePorta);
  319.                 if(nomePDGenerateAutomaticamente!=null && !nomePDGenerateAutomaticamente.contains(idPD)) {
  320.                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  321.                     if(resultPorta.mapping) {
  322.                         String l = resultPorta.label;
  323.                         if(mappingFruizionePD_list.contains(l)==false) { 
  324.                             mappingFruizionePD_list.add(l);
  325.                         }
  326.                     }
  327.                     else {
  328.                         // ?? e' gia' un mapping
  329.                         String l = resultPorta.label;
  330.                         if(porteDelegate_list.contains(l)==false) { 
  331.                             porteDelegate_list.add(l);
  332.                         }
  333.                     }
  334.                     isInUso=true;
  335.                 }
  336.             }
  337.             risultato.close();
  338.             stmt.close();
  339.             
  340.             
  341.             
  342.             
  343.             
  344.             // fruitori
  345.             if(mappingFruizionePD_list.isEmpty()) {
  346.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  347.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  348.                 sqlQueryObject.addFromTable(CostantiDB.SERVIZI_FRUITORI);
  349.                 sqlQueryObject.setSelectDistinct(true);
  350.                 sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".tipo_soggetto");
  351.                 sqlQueryObject.addSelectField(CostantiDB.SOGGETTI + ".nome_soggetto");
  352.                 sqlQueryObject.addWhereCondition(CostantiDB.SOGGETTI + ".id = " + CostantiDB.SERVIZI_FRUITORI + ".id_soggetto");
  353.                 sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI_FRUITORI + ".id_servizio = ?");
  354.                 sqlQueryObject.setANDLogicOperator(true);
  355.                 queryString = sqlQueryObject.createSQLQuery();
  356.                 stmt = con.prepareStatement(queryString);
  357.                 stmt.setLong(1, idAccordoServizioParteSpecifica);
  358.                 risultato = stmt.executeQuery();
  359.                 while (risultato.next()) {
  360.                                         
  361.                     String tipoSoggettoFruitore = risultato.getString("tipo_soggetto");
  362.                     String nomeSoggettoFruitore = risultato.getString("nome_soggetto");
  363.                     
  364.                     boolean usedForPD = false;
  365.                     if(nomePDGenerateAutomaticamente!=null) {
  366.                         for (IDPortaDelegata idPD : nomePDGenerateAutomaticamente) {
  367.                             if(idPD.getIdentificativiFruizione()!=null && idPD.getIdentificativiFruizione().getSoggettoFruitore()!=null) {
  368.                                 IDSoggetto soggettoFruitore = new IDSoggetto(tipoSoggettoFruitore, nomeSoggettoFruitore);
  369.                                 if(soggettoFruitore.equals(idPD.getIdentificativiFruizione().getSoggettoFruitore())) {
  370.                                     usedForPD = true;
  371.                                     break;
  372.                                 }
  373.                             }
  374.                         }
  375.                     }
  376.                     
  377.                     if(!usedForPD) {
  378.                         if(normalizeObjectIds) {
  379.                             fruitori_list.add(NamingUtils.getLabelSoggetto(new IDSoggetto(tipoSoggettoFruitore, nomeSoggettoFruitore)));
  380.                         }
  381.                         else {
  382.                             fruitori_list.add(tipoSoggettoFruitore+"/"+nomeSoggettoFruitore);
  383.                         }
  384.                         isInUso=true;
  385.                     }
  386.                 }
  387.                 risultato.close();
  388.                 stmt.close();
  389.             }
  390.             
  391.             
  392.             
  393.             
  394.             
  395.             // servizio Componente
  396.             //List<String> nomiServiziApplicativi = new ArrayList<>();
  397.             //controllo se in uso in servizi
  398.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  399.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPONENTI);
  400.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  401.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  402.             sqlQueryObject.setSelectDistinct(true);
  403.             sqlQueryObject.addSelectField(CostantiDB.ACCORDI + ".nome");
  404.             sqlQueryObject.addSelectField(CostantiDB.ACCORDI + ".versione");
  405.             sqlQueryObject.addSelectField(CostantiDB.ACCORDI + ".id_referente");
  406.             sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_composto = "+CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id");
  407.             sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo = "+CostantiDB.ACCORDI+".id");
  408.             sqlQueryObject.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPONENTI+".id_servizio_componente = ?");
  409.             sqlQueryObject.setANDLogicOperator(true);
  410.             queryString = sqlQueryObject.createSQLQuery();
  411.             stmt = con.prepareStatement(queryString);
  412.             stmt.setLong(1, idAccordoServizioParteSpecifica);
  413.             risultato = stmt.executeQuery();
  414.             while (risultato.next()){
  415.                 isInUso=true;
  416.                 
  417.                 String nomeAccordo = risultato.getString("nome");
  418.                 int versione = risultato.getInt("versione");
  419.                 long idReferente = risultato.getLong("id_referente");
  420.                 IDSoggetto idReferenteObject = null;
  421.                 
  422.                 if(idReferente>0){

  424.                     ISQLQueryObject sqlQueryObjectReferente = SQLObjectFactory.createSQLQueryObject(tipoDB);
  425.                     sqlQueryObjectReferente.addFromTable(CostantiDB.SOGGETTI);
  426.                     sqlQueryObjectReferente.addSelectField("*");
  427.                     sqlQueryObjectReferente.addWhereCondition("id=?");
  428.                     sqlQueryObjectReferente.setANDLogicOperator(true);
  429.                     String queryStringReferente = sqlQueryObjectReferente.createSQLQuery();
  430.                     stmt2 = con.prepareStatement(queryStringReferente);
  431.                     stmt2.setLong(1, idReferente);
  432.                     risultato2 = stmt2.executeQuery();
  433.                     if(risultato2.next()){
  434.                         idReferenteObject = new IDSoggetto();
  435.                         idReferenteObject.setTipo(risultato2.getString("tipo_soggetto"));
  436.                         idReferenteObject.setNome(risultato2.getString("nome_soggetto"));
  437.                     }
  438.                     risultato2.close(); risultato2=null;
  439.                     stmt2.close(); stmt2=null;

  441.                 }
  442.                 
  443.                 if(normalizeObjectIds && idReferenteObject!=null) {
  444.                     String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idReferenteObject.getTipo());
  445.                     IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromValues(nomeAccordo, idReferenteObject, versione); 
  446.                     servizioComponente_list.add(DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteComune(protocollo, idAccordo));
  447.                 }
  448.                 else {

  450.                     StringBuilder bf = new StringBuilder();

  452.                     bf.append(idReferenteObject!=null ? idReferenteObject.getTipo() : "?");
  453.                     bf.append("/");
  454.                     bf.append(idReferenteObject!=null ? idReferenteObject.getNome() : "?");
  455.                     bf.append(":");
  456.                     
  457.                     bf.append(nomeAccordo);
  458.     
  459.                     if(idReferente>0){
  460.                         bf.append(":");
  461.                         bf.append(versione);
  462.                     }
  463.     
  464.                     servizioComponente_list.add(bf.toString());
  465.                 }
  466.                 
  467.             }
  468.             risultato.close();
  469.             stmt.close();

  471.             
  472.             
  473.             
  474.             
  475.             
  476.             

  478.                         
  479.             
  480.             
  481.             // Controllo che il soggetto non sia associato ad utenti
  482.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  483.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  484.             sqlQueryObject.addFromTable(CostantiDB.USERS_SERVIZI);
  485.             sqlQueryObject.addSelectField("login");
  486.             sqlQueryObject.setANDLogicOperator(true);
  487.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SERVIZI+".id_servizio = ?");
  488.             sqlQueryObject.addWhereCondition(CostantiDB.USERS+".id = "+CostantiDB.USERS_SERVIZI+".id_utente");
  489.             queryString = sqlQueryObject.createSQLQuery();
  490.             stmt = con.prepareStatement(queryString);
  491.             stmt.setLong(1, idAccordoServizioParteSpecifica);
  492.             risultato = stmt.executeQuery();
  493.             while (risultato.next()) {
  494.                 utenti_list.add(risultato.getString("login"));

  496.                 isInUso = true;
  497.             }
  498.             risultato.close();
  499.             stmt.close();
  500.             
  501.             
  502.             
  503.             
  504.             
  505.             
  506.             
  507.             // Controllo che il servizio non sia associato a policy di controllo del traffico o allarmi
  508.                             
  509.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  510.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  511.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  512.             sqlQueryObject.addSelectField("tipo_soggetto");
  513.             sqlQueryObject.addSelectField("nome_soggetto");
  514.             sqlQueryObject.addSelectField("tipo_servizio");
  515.             sqlQueryObject.addSelectField("nome_servizio");
  516.             sqlQueryObject.addSelectField("versione_servizio");
  517.             sqlQueryObject.setANDLogicOperator(true);
  518.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id=?");
  519.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  520.             queryString = sqlQueryObject.createSQLQuery();
  521.             stmt = con.prepareStatement(queryString);
  522.             stmt.setLong(1, idAccordoServizioParteSpecifica);
  523.             risultato = stmt.executeQuery();
  524.             IDServizio idServizio = null;
  525.             if(risultato.next()) {
  526.                 idServizio = readIdServizio(risultato);
  527.             }
  528.             risultato.close();
  529.             stmt.close();
  530.             
  531.             if(idServizio!=null) {
  532.                 
  533.                 int max = 2;
  534.                 if(!CostantiDB.isAllarmiEnabled()) {
  535.                     max=1;
  536.                 }
  537.                 for (int i = 0; i < max; i++) {
  538.                     
  539.                     String tabella = CostantiDB.CONTROLLO_TRAFFICO_ACTIVE_POLICY;
  540.                     String identificativo_column = "active_policy_id";
  541.                     String alias_column = "policy_alias";
  542.                     List<String> list = ct_list;
  543.                     String oggetto = "Policy";
  544.                     if(i==1) {
  545.                         tabella = CostantiDB.ALLARMI;
  546.                         identificativo_column = "nome";
  547.                         alias_column = "alias";
  548.                         list = allarme_list;
  549.                         oggetto = "Allarme";
  550.                     }
  551.                 
  552.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  553.                     sqlQueryObject.addFromTable(tabella);
  554.                     sqlQueryObject.addSelectField(identificativo_column);
  555.                     sqlQueryObject.addSelectField(alias_column);
  556.                     sqlQueryObject.addSelectField("filtro_ruolo");
  557.                     sqlQueryObject.addSelectField("filtro_porta");
  558.                     sqlQueryObject.setANDLogicOperator(true); // OR
  559.                     sqlQueryObject.addWhereCondition(tabella+".filtro_tipo_erogatore = ?");
  560.                     sqlQueryObject.addWhereCondition(tabella+".filtro_nome_erogatore = ?");
  561.                     sqlQueryObject.addWhereCondition(tabella+".filtro_tipo_servizio = ?");
  562.                     sqlQueryObject.addWhereCondition(tabella+".filtro_nome_servizio = ?");
  563.                     sqlQueryObject.addWhereCondition(tabella+".filtro_versione_servizio = ?");
  564.                     sqlQueryObject.addOrderBy("filtro_ruolo");
  565.                     sqlQueryObject.addOrderBy("filtro_porta");
  566.                     queryString = sqlQueryObject.createSQLQuery();
  567.                     stmt = con.prepareStatement(queryString);
  568.                     index = 1;
  569.                     stmt.setString(index++, idServizio.getSoggettoErogatore().getTipo());
  570.                     stmt.setString(index++, idServizio.getSoggettoErogatore().getNome());
  571.                     stmt.setString(index++, idServizio.getTipo());
  572.                     stmt.setString(index++, idServizio.getNome());
  573.                     stmt.setInt(index++, idServizio.getVersione());
  574.                     risultato = stmt.executeQuery();
  575.                     while (risultato.next()) {
  576.                         
  577.                         String alias = risultato.getString(alias_column);
  578.                         if(alias== null || "".equals(alias)) {
  579.                             alias = risultato.getString(identificativo_column);
  580.                         }
  581.                         
  582.                         String nomePorta = risultato.getString("filtro_porta");
  583.                         String filtro_ruolo = risultato.getString("filtro_ruolo");
  584.                         if(nomePorta!=null) {
  585.                             String tipo = null;
  586.                             String label = null;
  587.                             if("delegata".equals(filtro_ruolo)) {
  588.                                 try {
  589.                                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaDelegata(nomePorta, tipoDB, con, normalizeObjectIds);
  590.                                     if(resultPorta.mapping) {
  591.                                         label = "Fruizione di Servizio "+ resultPorta.label;
  592.                                     }
  593.                                 }catch(Exception e) {
  594.                                     tipo = "Outbound";
  595.                                 }
  596.                             }
  597.                             else if("applicativa".equals(filtro_ruolo)) {
  598.                                 try {
  599.                                     ResultPorta resultPorta = DBOggettiInUsoUtils.formatPortaApplicativa(nomePorta, tipoDB, con, normalizeObjectIds);
  600.                                     if(resultPorta.mapping) {
  601.                                         label = "Erogazione di Servizio "+ resultPorta.label;
  602.                                     }
  603.                                 }catch(Exception e) {
  604.                                     tipo = "Inbound";
  605.                                 }
  606.                             }
  607.                             else {
  608.                                 tipo = filtro_ruolo;
  609.                             }
  610.                             if(label==null) {
  611.                                 list.add(oggetto+" '"+alias+"' attiva nella porta '"+tipo+"' '"+nomePorta+"' ");
  612.                             }
  613.                             else {
  614.                                 list.add(oggetto+" '"+alias+"' attiva nella "+label);
  615.                             }
  616.                         }
  617.                         else {
  618.                             list.add(oggetto+" '"+alias+"'");
  619.                         }
  620.         
  621.                         isInUso = true;
  622.                     }
  623.                     risultato.close();
  624.                     stmt.close();
  625.                 }
  626.             }
  627.             

  629.             
  630.             return isInUso;

  632.         } catch (Exception se) {

  634.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  635.         } finally {
  636.             //Chiudo statement and resultset
  637.             JDBCUtilities.closeResources(risultato2, stmt2);
  638.             JDBCUtilities.closeResources(risultato, stmt);
  639.         }
  640.     }
  641.     @SuppressWarnings("deprecation")
  642.     private static IDServizio readIdServizio(ResultSet risultato) throws SQLException {
  643.         IDServizio idServizio = new IDServizio();
  644.         idServizio.setTipo(risultato.getString("tipo_servizio"));
  645.         idServizio.setNome(risultato.getString("nome_servizio"));
  646.         idServizio.setVersione(risultato.getInt("versione_servizio"));
  647.         idServizio.setSoggettoErogatore(new IDSoggetto(risultato.getString("tipo_soggetto"), risultato.getString("nome_soggetto")));
  648.         return idServizio;
  649.     }
  650.     
  651.     protected static boolean isAccordoServizioParteSpecificaInUso(Connection con, String tipoDB, IDServizio idServizio, 
  652.             Map<ErrorsHandlerCostant,List<String>> whereIsInUso,
  653.             List<IDPortaDelegata> nomePDGenerateAutomaticamente, List<IDPortaApplicativa> nomePAGenerateAutomaticamente, boolean normalizeObjectIds) throws UtilsException {
  654.         String nomeMetodo = "isAccordoServizioParteSpecificaInUso(IDServizio)";
  655.         long idAccordoServizioParteSpecifica = -1;
  656.         try {
  657.             idAccordoServizioParteSpecifica = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, tipoDB);
  658.             if(idAccordoServizioParteSpecifica<=0){
  659.                 throw new UtilsException("Accordi di Servizio Parte Specifica con id ["+idServizio.toString()+"] non trovato");
  660.             }
  661.         }catch (Exception se) {
  662.             throw new UtilsException("[DBOggettiInUsoUtils::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  663.         }
  664.         return isAccordoServizioParteSpecificaInUso(con, tipoDB, idAccordoServizioParteSpecifica, whereIsInUso,nomeMetodo,
  665.                 nomePDGenerateAutomaticamente, nomePAGenerateAutomaticamente, normalizeObjectIds);
  666.     }
  667.     protected static String toString(IDServizio idServizio, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean prefix, String separator, 
  668.             boolean normalizeObjectIds, String oggetto){
  669.         
  670.         StringBuilder bf = new StringBuilder();
  671.         if(normalizeObjectIds) {
  672.             try {
  673.                 String protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(idServizio.getSoggettoErogatore().getTipo());
  674.                 String labelAccordo = DBOggettiInUsoUtils.getProtocolPrefix(protocollo)+NamingUtils.getLabelAccordoServizioParteSpecifica(protocollo, idServizio);
  675.                 bf.append(labelAccordo);
  676.             }catch(Exception e) {
  677.                 bf.append(idServizio.toString());
  678.             }
  679.         }
  680.         else {
  681.             bf.append(idServizio.toString());
  682.         }
  683.         
  684.         
  685.         Set<ErrorsHandlerCostant> keys = whereIsInUso.keySet();
  686.         String msg = oggetto+ " '"+bf.toString() + "' non eliminabile perch&egrave; :"+separator;
  687.         if(prefix==false){
  688.             msg = "";
  689.         }
  690.         String separatorCategorie = "";
  691.         if(whereIsInUso.size()>1) {
  692.             separatorCategorie = separator;
  693.         }
  694.         for (ErrorsHandlerCostant key : keys) {
  695.             List<String> messages = whereIsInUso.get(key);

  697.             if ( messages!=null && messages.size() > 0) {
  698.                 msg += separatorCategorie;
  699.             }
  700.             
  701.             switch (key) {
  702.             case IN_USO_IN_PORTE_DELEGATE:
  703.                 if ( messages!=null && messages.size() > 0 ) {
  704.                     msg += "in uso in Porte Delegate: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  705.                 }
  706.                 break;
  707.             case IN_USO_IN_PORTE_APPLICATIVE:
  708.                 if ( messages!=null && messages.size() > 0 ) {
  709.                     msg += "in uso in Porte Applicative: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  710.                 }
  711.                 break;
  712.             case POSSIEDE_FRUITORI:
  713.                 if ( messages!=null && messages.size() > 0 ) {
  714.                     msg += "fruito dai soggetti: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  715.                 }
  716.                 break;
  717.             case IS_SERVIZIO_COMPONENTE_IN_ACCORDI:
  718.                 if ( messages!=null && messages.size() > 0 ) {
  719.                     msg += "associato come servizio componente in API di Servizi Composti: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  720.                 }
  721.                 break;
  722.             case IN_USO_IN_MAPPING_EROGAZIONE_PA:
  723.                 if ( messages!=null && messages.size() > 0) {
  724.                     msg += "utilizzato nelle Erogazioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  725.                 }
  726.                 break;
  727.             case IN_USO_IN_MAPPING_FRUIZIONE_PD:
  728.                 if ( messages!=null && messages.size() > 0) {
  729.                     msg += "utilizzato nelle Fruizioni: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  730.                 }
  731.                 break;
  732.             case UTENTE:
  733.                 if ( messages!=null && messages.size() > 0 ) {
  734.                     msg += "associato ad Utenti: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  735.                 }
  736.                 break;
  737.             case CONTROLLO_TRAFFICO:
  738.                 if ( messages!=null && messages.size() > 0 ) {
  739.                     msg += "utilizzato in policy di Rate Limiting: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  740.                 }
  741.                 break;
  742.             case ALLARMI:
  743.                 if ( messages!=null && messages.size() > 0 ) {
  744.                     msg += "utilizzato in Allarmi: " + DBOggettiInUsoUtils.formatList(messages,separator) + separator;
  745.                 }
  746.                 break;
  747.             default:
  748.                 msg += "utilizzato in oggetto non codificato ("+key+")"+separator;
  749.                 break;
  750.             }

  752.         }// chiudo for

  754.         return msg;
  755.     }
  756.     
  757. }
Created with JaCoCo 0.8.8.202204050719