ConfigurazioneCondizionale.java

/*
 * GovWay - A customizable API Gateway
 * https://govway.org
 * 
 * Copyright (c) 2005-2024 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.pdd.core.behaviour.conditional;

import java.util.Set;
import java.util.TreeMap;

import org.openspcoop2.core.registry.Resource;
import org.openspcoop2.pdd.core.Utilities;
import org.openspcoop2.pdd.core.behaviour.BehaviourException;
import org.openspcoop2.utils.regexp.RegExpException;
import org.openspcoop2.utils.regexp.RegExpNotFoundException;
import org.openspcoop2.utils.regexp.RegExpNotValidException;
import org.openspcoop2.utils.regexp.RegularExpressionEngine;

/**
 * ConfigurazioneCondizionale
 *
 * @author Andrea Poli (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class ConfigurazioneCondizionale {

	private boolean byFilter = true; 
	private ConfigurazioneSelettoreCondizione defaultConfig;
	private TreeMap<String, ConfigurazioneSelettoreCondizioneRegola> regolaList = new TreeMap<>();
	
	private IdentificazioneFallitaConfigurazione condizioneNonIdentificata;
	private IdentificazioneFallitaConfigurazione nessunConnettoreTrovato; 
	
	public boolean isByFilter() {
		return this.byFilter;
	}
	public void setByFilter(boolean byFilter) {
		this.byFilter = byFilter;
	}
	
	public ConfigurazioneSelettoreCondizione getDefaultConfig() {
		return this.defaultConfig;
	}
	public void setDefaultConfig(ConfigurazioneSelettoreCondizione defaultConfig) {
		this.defaultConfig = defaultConfig;
	}
	
	public void addRegola(ConfigurazioneSelettoreCondizioneRegola config) throws BehaviourException {
		// check che una regola non sia già registrata
		if(config.getRegola()==null) {
			throw new BehaviourException("Nome Regola non indicata");
		}
		if(!this.regolaList.isEmpty()) {
			for (String nomeRegola : this.regolaList.keySet()) {
				if(nomeRegola.equalsIgnoreCase(config.getRegola())) {
					throw new BehaviourException("Esiste già una regola con nome '"+nomeRegola+"'");
				}
			}
		}
		this.regolaList.put(config.getRegola(), config);
	}
	
	public ConfigurazioneSelettoreCondizioneRegola getRegolaByOperazione(String operazione, Resource restResource) throws RegExpException {
		if(!this.regolaList.isEmpty()) {
			for (String nomeRegola: getRegoleOrdinate()) {
				ConfigurazioneSelettoreCondizioneRegola config = this.regolaList.get(nomeRegola);
				
				boolean match = isMatch(operazione, restResource, config);
				
				if(match) {
					return config;
				}
			}
		}
		return null;
	}
	
	private boolean isMatch(String operazione, Resource restResource, ConfigurazioneSelettoreCondizioneRegola config) throws RegExpException {
		boolean match = false;
		
		if(operazione.equals(config.getPatternOperazione())) {
			match=true;
		}
		
		if(!match && restResource!=null &&
			config.getPatternOperazione()!=null && !"".equals(config.getPatternOperazione())) {
			String [] parseResourceRest = Utilities.parseResourceRest(config.getPatternOperazione());
			if(parseResourceRest!=null) {
				match = Utilities.isRestResourceMatch(parseResourceRest, restResource);
			}
		}
		
		if(!match) {
			boolean exprRegular = false;
			try {
				RegularExpressionEngine.validate(config.getPatternOperazione());
				exprRegular = true;
			}catch(Exception e) {
				// ignore
			}
			if(exprRegular) {
				try {
					match = RegularExpressionEngine.isMatch(operazione, config.getPatternOperazione());
				}
				catch(RegExpNotValidException | RegExpNotFoundException e) {
					// RegExpNotValidException: non dovrebbe accadere, garantito da validate sopra
					// RegExpNotFoundException: ignore
				}
			}
		}
		
		return match;
	}

	public String getNomeRegolaByOperazione(String operazione, Resource restResource) throws RegExpException {
		ConfigurazioneSelettoreCondizioneRegola c = this.getRegolaByOperazione(operazione, restResource);
		return c!=null ? c.getRegola() : null;
	}
	public ConfigurazioneSelettoreCondizioneRegola getRegola(String nomeRegola) {
		return this.regolaList.get(nomeRegola);
	}
	public Set<String> getRegoleOrdinate(){
		
		return this.regolaList.keySet();
	}
	public void removeRegola(String nomeRegola){
		this.regolaList.remove(nomeRegola);
	}
	public int sizeRegole() {
		return this.regolaList.size();
	}
	public TreeMap<String, ConfigurazioneSelettoreCondizioneRegola> getRegolaList() {
		return this.regolaList;
	}
	public void setRegolaList(TreeMap<String, ConfigurazioneSelettoreCondizioneRegola> regolaList) {
		this.regolaList = regolaList;
	}
	
	public IdentificazioneFallitaConfigurazione getCondizioneNonIdentificata() {
		return this.condizioneNonIdentificata;
	}
	public void setCondizioneNonIdentificata(IdentificazioneFallitaConfigurazione condizioneNonIdentificata) {
		this.condizioneNonIdentificata = condizioneNonIdentificata;
	}
	public IdentificazioneFallitaConfigurazione getNessunConnettoreTrovato() {
		return this.nessunConnettoreTrovato;
	}
	public void setNessunConnettoreTrovato(IdentificazioneFallitaConfigurazione nessunConnettoreTrovato) {
		this.nessunConnettoreTrovato = nessunConnettoreTrovato;
	}
	
}