AutorizzazioneSignalHubPush.java

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



package org.openspcoop2.protocol.modipa.authorization;

import java.util.List;

import org.openspcoop2.core.config.Ruolo;
import org.openspcoop2.core.registry.ProtocolProperty;
import org.openspcoop2.pdd.core.PdDContext;
import org.openspcoop2.pdd.core.autorizzazione.pd.AbstractAutorizzazioneBase;
import org.openspcoop2.pdd.core.autorizzazione.pd.DatiInvocazionePortaDelegata;
import org.openspcoop2.pdd.core.autorizzazione.pd.EsitoAutorizzazionePortaDelegata;
import org.openspcoop2.protocol.modipa.config.ModIProperties;
import org.openspcoop2.protocol.modipa.constants.ModICostanti;
import org.openspcoop2.protocol.modipa.utils.SignalHubUtils;
import org.openspcoop2.protocol.sdk.ProtocolException;
import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
import org.openspcoop2.protocol.sdk.properties.ProtocolPropertiesUtils;

/**
 * Interfaccia che definisce un processo di autorizzazione sui token
 *
 * @author Tommaso Burlon (tommaso.burlon@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */

public class AutorizzazioneSignalHubPush extends AbstractAutorizzazioneBase {

	private static final String GENERIC_ERROR = "Errore di processamento dell'autorizzazione signal hub";
	private static final String ROLE_SERVICE_UNRECOGNIZED = "L'applicativo autenticato non è configurato come pubblicatore del servizio indicato, né tramite assegnazione diretta né mediante ruolo associato";
	
	@Override
	public boolean saveAuthorizationResultInCache() {
		return false;
	}
	
    @Override
	public EsitoAutorizzazionePortaDelegata process(DatiInvocazionePortaDelegata datiInvocazione){    	
    	try {
    		// controllo che signalhub sia abilitato
    		ModIProperties modiProperties = ModIProperties.getInstance();
    		if(!modiProperties.isSignalHubEnabled()) { 
    			throw new ProtocolException("La funzionalità SignalHub non è attiva");
    		}
    		
    		return this.processEngine(datiInvocazione);
    	} catch (ProtocolException e) {
    		return buildConfigurazioneNonDisponibile(null, e);
    	}
    }
    
    private EsitoAutorizzazionePortaDelegata buildConfigurazioneNonDisponibile(String descrizioneErrore, Exception e) {
    	EsitoAutorizzazionePortaDelegata esito = new EsitoAutorizzazionePortaDelegata();
		esito.setErroreIntegrazione(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
				descrizioneErrore!=null ? 
						 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(descrizioneErrore, CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE)
						:
							 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
		esito.setAutorizzato(false);
		esito.setDetails(GENERIC_ERROR);
		esito.setEccezioneProcessamento(e);
		return esito;
    }
    
    public EsitoAutorizzazionePortaDelegata processEngine(DatiInvocazionePortaDelegata datiInvocazione) throws ProtocolException {
    	EsitoAutorizzazionePortaDelegata esito = new EsitoAutorizzazionePortaDelegata();
    	
		PdDContext context = datiInvocazione.getPddContext();
    	
		// ottengo le proprieta del protocollo per avere gli applicativi/ruoli autorizzati
		List<ProtocolProperty> eServiceProperties = SignalHubUtils.obtainSignalHubProtocolProperty(context);
    	
		String allowedService = null;
		try {
			allowedService = ProtocolPropertiesUtils.getRequiredStringValuePropertyRegistry(eServiceProperties, ModICostanti.MODIPA_API_IMPL_INFO_SIGNAL_HUB_PUBLISHER_SA_ID);
		}catch(Exception e) {
			if(getProtocolFactory().getLogger()!=null) {
				getProtocolFactory().getLogger().error("Configurazione SignalHub non fornita per il servizio indicato: "+e.getMessage(),e);
			}
			return buildConfigurazioneNonDisponibile("Configurazione SignalHub non fornita per il servizio indicato", e);
		}
		String allowedRole = null;
		try {
			allowedRole = ProtocolPropertiesUtils.getRequiredStringValuePropertyRegistry(eServiceProperties, ModICostanti.MODIPA_API_IMPL_INFO_SIGNAL_HUB_PUBLISHER_ROLE_ID);
		}catch(Exception e) {
			if(getProtocolFactory().getLogger()!=null) {
				getProtocolFactory().getLogger().error("Configurazione SignalHub non fornita per il servizio indicato: "+e.getMessage(),e);
			}
			return buildConfigurazioneNonDisponibile("Configurazione SignalHub non fornita per il servizio indicato", e);
		}
			

		List<Ruolo> roles = List.of();
		
		// controllo se sono presenti ruoli nel servizio applicativo
		if (datiInvocazione.getServizioApplicativo() != null && 
			datiInvocazione.getServizioApplicativo().getInvocazionePorta() != null &&
			datiInvocazione.getServizioApplicativo().getInvocazionePorta().getRuoli() != null)
			roles = datiInvocazione.getServizioApplicativo().getInvocazionePorta().getRuoli().getRuoloList();
		
		// controllo se sono presenti ruoli autorizzati
		for (Ruolo role : roles) {
			if (role.getNome().equals(allowedRole)) {
				esito.setAutorizzato(true);
				return esito;
			}
		}
		
		// controllo se l'applicativo e' autorizzato
		if (datiInvocazione.getIdServizioApplicativo() == null) {
			esito.setAutorizzato(false);
			esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_DENY, ErroriIntegrazione.ERRORE_410_AUTENTICAZIONE_RICHIESTA.getErroreIntegrazione());
			/**esito.setDetails(ROLE_SERVICE_UNRECOGNIZED);*/
			
		} else if (!allowedService.equals(datiInvocazione.getIdServizioApplicativo().getNome())) {
			esito.setAutorizzato(false);
			esito.setErroreIntegrazione(IntegrationFunctionError.AUTHORIZATION_DENY, ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA.getErrore404_AutorizzazioneFallitaServizioApplicativo(datiInvocazione.getIdServizioApplicativo().getNome()));
			esito.setDetails(ROLE_SERVICE_UNRECOGNIZED);
		} else {
			esito.setAutorizzato(true);
		}
		
		return esito;
    }
	
}