SignalHubPushInProtocolRequestHandler.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.  */
  20. package org.openspcoop2.protocol.modipa.handlers;

  22. import java.lang.reflect.InvocationTargetException;
  23. import java.util.ArrayList;
  24. import java.util.List;
  25. import java.util.Map;
  26. import java.util.Objects;
  27. import java.util.Optional;
  28. import java.util.stream.Collectors;

  30. import org.openspcoop2.core.commons.CoreException;
  31. import org.openspcoop2.core.constants.CostantiDB;
  32. import org.openspcoop2.core.constants.TipoPdD;
  33. import org.openspcoop2.core.id.IDAccordo;
  34. import org.openspcoop2.core.id.IDServizio;
  35. import org.openspcoop2.core.id.IDSoggetto;
  36. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  37. import org.openspcoop2.core.registry.Fruitore;
  38. import org.openspcoop2.core.registry.ProtocolProperty;
  39. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  40. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  41. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  42. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziGet;
  43. import org.openspcoop2.pdd.core.dynamic.DynamicException;
  44. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  45. import org.openspcoop2.pdd.core.handlers.HandlerException;
  46. import org.openspcoop2.pdd.core.handlers.InRequestContext;
  47. import org.openspcoop2.pdd.core.handlers.InRequestHandler;
  48. import org.openspcoop2.protocol.basic.registry.RegistryReader;
  49. import org.openspcoop2.protocol.modipa.config.ModIProperties;
  50. import org.openspcoop2.protocol.modipa.config.ModISignalHubConfig;
  51. import org.openspcoop2.protocol.modipa.config.ModISignalHubParamConfig;
  52. import org.openspcoop2.protocol.modipa.constants.ModICostanti;
  53. import org.openspcoop2.protocol.modipa.constants.ModISignalHubOperation;
  54. import org.openspcoop2.protocol.modipa.properties.ModIDynamicConfigurationAccordiParteComuneUtilities;
  55. import org.openspcoop2.protocol.modipa.utils.ModIUtilities;
  56. import org.openspcoop2.protocol.registry.RegistroServiziReader;
  57. import org.openspcoop2.protocol.sdk.Context;
  58. import org.openspcoop2.protocol.sdk.ProtocolException;
  59. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  60. import org.openspcoop2.protocol.sdk.properties.ProtocolProperties;
  61. import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;
  62. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  63. import org.openspcoop2.protocol.sdk.registry.ProtocolFiltroRicercaServizi;
  64. import org.openspcoop2.protocol.sdk.registry.RegistryException;
  65. import org.openspcoop2.protocol.sdk.registry.RegistryNotFound;
  66. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  67. import org.openspcoop2.utils.BooleanNullable;
  68. import org.openspcoop2.utils.service.beans.ProfiloEnum;
  69. import org.openspcoop2.utils.service.beans.utils.ProfiloUtils;
  70. import org.slf4j.Logger;

  72. /**
  73.  * SignalHubPushInRequestHandler
  74.  *
  75.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  76.  * @author $Author$
  77.  * @version $Rev$, $Date$
  78.  */
  79. public class SignalHubPushInProtocolRequestHandler implements InRequestHandler {
  80.     
  81.     @Override
  82.     public void invoke(InRequestContext context) throws HandlerException {
  83.         try {
  84.             if (checkSignalHubPushConditions(context)) {
  85.                 List<ProtocolProperty> props = getSignalHubPushProperty(context);
  86.                 parseSignalHubPushProperty(context, props);
  87.             }
  88.         } catch (ProtocolException 
  89.                 | DriverRegistroServiziException 
  90.                 | DynamicException 
  91.                 | RegistryNotFound 
  92.                 | RegistryException e) {
  93.             throw new HandlerException(e);
  94.         } 
  95.     }
  96.     
  97.     private boolean checkSignalHubPushConditions(InRequestContext context) throws ProtocolException, DriverRegistroServiziException, RegistryNotFound, RegistryException {
  98.         Logger logger = context.getLogCore();
  99.         
  100.         
  101.         // controllo che signalhub sia abilitato
  102.         ModIProperties modiProperties = ModIProperties.getInstance();
  103.         if(!modiProperties.isSignalHubEnabled()) { 
  104.             return false;
  105.         }
  106.         
  107.         // controllo che sia una fruizione ModI
  108.         if (context.getTipoPorta() == null
  109.                 || !context.getTipoPorta().equals(TipoPdD.DELEGATA)
  110.                 || context.getPddContext() == null)
  111.             return false;
  112.         
  113.         IRegistryReader registryReader = this.getIRegistryReader(context);

  115.         
  116.         // controllo che l'id dell'accordo sia raggiungibile
  117.         AccordoServizioParteSpecifica asps = registryReader.getAccordoServizioParteSpecifica(this.getRequestInfo(context).getIdServizio());
  118.         IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  119.         if (idAccordo == null)
  120.             return false;
  121.         
  122.         
  123.         // controllo che l'accordo sia l'accordo built-in per la registrazione dei segnali
  124.         boolean isApiSignalHubPushAPI = false;
  125.             
  126.         Map<String, IDriverRegistroServiziGet> readers = RegistroServiziReader.getDriverRegistroServizi();

  128.         for (Map.Entry<String, IDriverRegistroServiziGet> entry : readers.entrySet()) {
  129.             IRegistryReader reader;
  130.             try {
  131.                 reader = new RegistryReader(entry.getValue(), logger);
  132.                 isApiSignalHubPushAPI |= ModIDynamicConfigurationAccordiParteComuneUtilities.isApiSignalHubPushAPI(idAccordo, reader, ModIProperties.getInstance(), logger);
  133.             } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | IllegalArgumentException
  134.                     | InvocationTargetException | NoSuchMethodException | SecurityException e) {
  135.                 // ignore
  136.             }
  137.         }
  138.         
  139.         if (!isApiSignalHubPushAPI)
  140.             return false;
  141.         
  142.         logger.debug("Nuova richiesta di deposito di segnali SignalHub");
  143.         
  144.         return true;
  145.     }
  146.     
  147.     
  148.     private RequestInfo getRequestInfo(InRequestContext context) {
  149.         return (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  150.     }
  151.     
  152.     private IRegistryReader getIRegistryReader(InRequestContext context) throws ProtocolException {
  153.         return context.getProtocolFactory().getCachedRegistryReader(context.getStato(), this.getRequestInfo(context));
  154.     }
  155.     
  156.     private IDSoggetto getFruitore(InRequestContext context) {
  157.         return this.getRequestInfo(context).getFruitore();
  158.     }
  159.     
  160.     private List<ProtocolProperty> getSignalHubPushProperty(InRequestContext context) throws ProtocolException, RegistryNotFound, RegistryException {
  161.         IRegistryReader reader = this.getIRegistryReader(context);
  162.         IDServizio servizio = this.getRequestInfo(context).getIdServizio();
  163.         IDSoggetto idFruitore = this.getFruitore(context);
  164.         
  165.         AccordoServizioParteSpecifica asps = reader.getAccordoServizioParteSpecifica(servizio, false);
  166.         List<Fruitore> fruitori = Objects.requireNonNullElseGet(asps.getFruitoreList(), ArrayList::new);
  167.         
  168.         Optional<Fruitore> fruitore = fruitori
  169.                 .stream().filter(f -> f.getNome().equals(idFruitore.getNome()) && f.getTipo().equals(idFruitore.getTipo()))
  170.                 .findAny();
  171.                 
  172.         if (fruitore.isEmpty())
  173.             return List.of();
  174.         
  175.         List<ProtocolProperty> props = fruitore.get().getProtocolPropertyList();
  176.         if (props != null && !props.isEmpty())
  177.             return props;
  178.             
  179.         return List.of();
  180.     }

  182.     private String getDynamicProperty(List<ProtocolProperty> props, ModISignalHubParamConfig param, Context context, Map<String, Object> dynamicMap, boolean useDefault) throws ProtocolException {
  183.         try {
  184.             String key = CostantiDB.MODIPA_API_IMPL_PUSH_SIGNAL_HUB_PARAM_VALUE_ID_PREFIX + param.getPropertyId();
  185.             String mode = ProtocolPropertiesUtils.getRequiredStringValuePropertyRegistry(props, CostantiDB.MODIPA_API_IMPL_PUSH_SIGNAL_HUB_PARAM_MODE_ID_PREFIX + param.getPropertyId());
  186.             String ridefinedValue = ProtocolPropertiesUtils.getOptionalStringValuePropertyRegistry(props, CostantiDB.MODIPA_API_IMPL_PUSH_SIGNAL_HUB_PARAM_VALUE_ID_PREFIX + param.getPropertyId());
  187.             List<String> values = null;
  188.                     
  189.             // se il campo e' stato ridefinito uso il template ridefinito altrimenti quello di default
  190.             if (!useDefault && mode.equals(CostantiDB.MODIPA_PROFILO_RIDEFINISCI)) {
  191.                 values = List.of(ridefinedValue);
  192.             } else {
  193.                 values = param.getRules();
  194.             }
  195.     
  196.             return ModIUtilities.getDynamicValue(key, values, dynamicMap, context);
  197.         } catch (ProtocolException e) {
  198.             return null;
  199.         }
  200.     }
  201.     
  202.     private void parseSignalHubPushProperty(InRequestContext context, List<ProtocolProperty> props) throws ProtocolException, DynamicException, HandlerException, RegistryNotFound, RegistryException, NumberFormatException, DriverRegistroServiziException { 
  203.         ModIProperties modiProperties = ModIProperties.getInstance();
  204.         ModISignalHubConfig signalHubConfig = modiProperties.getSignalHubConfig();
  205.         Logger logger = context.getLogCore();

  207.         Map<String, ModISignalHubParamConfig> claims = signalHubConfig.getClaims()
  208.                 .stream()
  209.                 .collect(Collectors.toMap(v -> v.getPropertyId(), v -> v));
  210.         
  211.         Map<String, Object> dynamicMap = DynamicUtils.buildDynamicMap(context.getMessaggio(), context.getPddContext(), null, logger, modiProperties.isReadByPathBufferEnabled());

  213.         // controllo se il segnale e' un segnale di SEEDUPDATE in tal caso le informazioni saranne messe da govway negli header di default
  214.         boolean isSeedUpdate = false;
  215.         String signalTypeRaw = getDynamicProperty(props, claims.get(ModICostanti.MODIPA_SIGNAL_HUB_ID_SIGNAL_TYPE), context.getPddContext(), dynamicMap, true);
  216.         ModISignalHubOperation signalType = ModISignalHubOperation.fromString(signalTypeRaw);
  217.         
  218.         if (signalType != null && signalType.equals(ModISignalHubOperation.SEEDUPDATE))
  219.             isSeedUpdate = true;
  220.         
  221.         // ottengo le varie informaizoni di deposito del segnale (nel caso di seedupdate usero i template di default)
  222.         String objectId = getDynamicProperty(props, claims.get(ModICostanti.MODIPA_SIGNAL_HUB_ID_OBJECT_ID), context.getPddContext(), dynamicMap, isSeedUpdate);
  223.         String objectType = getDynamicProperty(props, claims.get(ModICostanti.MODIPA_SIGNAL_HUB_ID_OBJECT_TYPE), context.getPddContext(), dynamicMap, isSeedUpdate);
  224.         signalTypeRaw = getDynamicProperty(props, claims.get(ModICostanti.MODIPA_SIGNAL_HUB_ID_SIGNAL_TYPE), context.getPddContext(), dynamicMap, isSeedUpdate);

  226.         if (objectId == null) {
  227.             throw newHandlerException("Parametro obbligatorio 'objectId' non rilevato", IntegrationFunctionError.BAD_REQUEST);
  228.         }
  229.         if (objectType == null) {
  230.             throw newHandlerException("Parametro obbligatorio 'objectType' non rilevato", IntegrationFunctionError.BAD_REQUEST);
  231.         }
  232.         if (signalTypeRaw == null) {
  233.             throw newHandlerException("Parametro obbligatorio 'signalType' non rilevato", IntegrationFunctionError.BAD_REQUEST);
  234.         }
  235.         
  236.         signalType = ModISignalHubOperation.fromString(signalTypeRaw);
  237.         if (signalType == null) {
  238.             throw newHandlerException("Parametro 'signalType' con valore errato '"+signalTypeRaw+"'; valori supportati: UPDATE, CREATE, DELETE", IntegrationFunctionError.BAD_REQUEST);
  239.         }
  240.         
  241.         String service = null;
  242.         String serviceVersion = null;
  243.         String serviceId = null;
  244.         
  245.         service = getDynamicProperty(props, claims.get("service"), context.getPddContext(), dynamicMap, isSeedUpdate);
  246.         serviceVersion = getDynamicProperty(props, claims.get("serviceVersion"), context.getPddContext(), dynamicMap, isSeedUpdate);
  247.         serviceId = getDynamicProperty(props, claims.get("serviceId"), context.getPddContext(), dynamicMap, isSeedUpdate);
  248.         
  249.         
  250.         IRegistryReader reader = this.getIRegistryReader(context);
  251.         
  252.         IDServizio idServizio = null;
  253.         List<ProtocolProperty> eServiceProperties = null;
  254.         
  255.         if (serviceId == null && (service == null || serviceVersion == null)) {
  256.             throw newHandlerException("Un serviceId o in alternativa il nome e la versione devono essere obbligatoriamente indicati per poter individuare il servizio", IntegrationFunctionError.BAD_REQUEST);
  257.         }
  258.         
  259.         // se tutte le informazioni sono presenti ottengo il serviceId a partire dall'id del servizio
  260.         if (serviceId == null) {
  261.             
  262.             int versioneServizio = -1;
  263.             try {
  264.                 versioneServizio = Integer.valueOf(serviceVersion);
  265.                 if(versioneServizio<=0) {
  266.                     throw new CoreException("Valore deve essere maggiore di zero");
  267.                 }
  268.             }catch(Exception e) {
  269.                 String msg = "Parametro 'serviceVersion' presenta un valore '"+serviceVersion+"' non valido; deve essere un numero intero maggiore di zero";
  270.                 logger.error(msg+": "+e.getMessage(), e);
  271.                 throw newHandlerException(msg, IntegrationFunctionError.BAD_REQUEST);
  272.             }
  273.             
  274.             try {
  275.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(
  276.                         ProfiloUtils.toProtocollo(ProfiloEnum.MODIPA), 
  277.                         service,
  278.                         this.getFruitore(context), 
  279.                         versioneServizio);
  280.                         AccordoServizioParteSpecifica asps = reader.getAccordoServizioParteSpecifica(idServizio);
  281.                         eServiceProperties = asps.getProtocolPropertyList();
  282.             }catch(RegistryNotFound notFound) {
  283.                 String nomeSoggetto = idServizio!=null && idServizio.getSoggettoErogatore()!=null && idServizio.getSoggettoErogatore().getNome()!=null ? idServizio.getSoggettoErogatore().getNome() : "Non identificato";
  284.                 throw newHandlerException("Il soggetto '"+nomeSoggetto+"' non risulta erogare un servizio con nome '"+service+"'  e versione '"+versioneServizio+"'", IntegrationFunctionError.BAD_REQUEST);
  285.             }
  286.         } else {
  287.             // altrimenti ottengo l'id sdel servizio partendo dal serviceId
  288.             ProtocolFiltroRicercaServizi filter = new ProtocolFiltroRicercaServizi();
  289.             ProtocolProperties filterProps = new ProtocolProperties();
  290.             filterProps.addProperty(ModICostanti.MODIPA_API_IMPL_INFO_ESERVICE_ID, serviceId);
  291.             filter.setProtocolPropertiesServizi(filterProps);
  292.             
  293.             List<IDServizio> idServices = null;
  294.             try {
  295.                 idServices = reader.findIdAccordiServizioParteSpecifica(filter);
  296.             }catch(RegistryNotFound notFound) {
  297.                 // ignore
  298.             }
  299.             logger.debug("id servizi: {}", idServices);
  300.             
  301.             if (idServices==null || idServices.isEmpty() || idServices.get(0)==null) {
  302.                 throw newHandlerException("Non esiste una erogazione di servizio registrato con l'id servizio '"+serviceId+"' indicato", IntegrationFunctionError.BAD_REQUEST);
  303.             }
  304.             
  305.             idServizio = idServices.get(0);
  306.             
  307.             IDSoggetto soggettoFruitore = this.getFruitore(context);
  308.             if (!idServizio.getSoggettoErogatore().equals(soggettoFruitore)) {
  309.                 context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTORIZZAZIONE, "true");
  310.                 throw newHandlerException("L'erogazione di servizio individuata con l'id servizio '"+serviceId+"' appartiene ad un soggetto '"+idServizio.getSoggettoErogatore().getNome()+"' differente dal soggetto pubblicatore '"+soggettoFruitore.getNome()+"'", 
  311.                         IntegrationFunctionError.AUTHORIZATION_DENY);
  312.             }

  314.             AccordoServizioParteSpecifica asps = reader.getAccordoServizioParteSpecifica(idServizio);
  315.             eServiceProperties = asps.getProtocolPropertyList();
  316.         }
  317.         
  318.         try {
  319.             serviceId = ProtocolPropertiesUtils.getRequiredStringValuePropertyRegistry(eServiceProperties, ModICostanti.MODIPA_API_IMPL_INFO_ESERVICE_ID);
  320.         }catch(Exception e) {
  321.             // succede nel caso di name e version
  322.             throw newHandlerException("L'erogazione del servizio indicato non contiene la configurazione relativa al serviceId", IntegrationFunctionError.BAD_REQUEST);
  323.         }
  324.         
  325.         try {
  326.             BooleanNullable signalHub = ProtocolPropertiesUtils.getOptionalBooleanValuePropertyRegistry(eServiceProperties, ModICostanti.MODIPA_API_IMPL_INFO_SIGNAL_HUB_ID);
  327.             if(signalHub==null || signalHub.getValue()==null || !signalHub.getValue().booleanValue()) {
  328.                 throw new CoreException("Non Attiva");
  329.             }
  330.         }catch(Exception e) {
  331.             // succede nel caso non sia stata attuata la configurazione
  332.             String msg = "Nell'erogazione del servizio indicato non risulta attiva la funzionalità Signal Hub";
  333.             logger.error(msg+": "+e.getMessage(), e);
  334.             throw newHandlerException(msg, IntegrationFunctionError.BAD_REQUEST);
  335.         }
  336.         
  337.         context.getPddContext().addObject(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_OBJECT_ID, objectId);
  338.         context.getPddContext().addObject(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_ESERVICE_ID, serviceId);
  339.         context.getPddContext().addObject(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_SERVICE, idServizio);
  340.         context.getPddContext().addObject(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_OBJECT_TYPE, objectType);
  341.         context.getPddContext().addObject(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_SIGNAL_TYPE, signalType);
  342.         context.getPddContext().addObject(ModICostanti.MODIPA_KEY_INFO_SIGNAL_HUB_PROPERTIES, eServiceProperties);
  343.     }

  345.     private HandlerException newHandlerException(String msg, IntegrationFunctionError error) {
  346.         HandlerException he = new HandlerException(msg);
  347.         he.setIntegrationFunctionError(error);
  348.         return he;
  349.     }
  350. }
Created with JaCoCo 0.8.8.202204050719