ModIValidazioneAuditClaimValue.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.protocol.modipa.validator;

import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.openspcoop2.protocol.modipa.config.ModIAuditClaimConfig;
import org.openspcoop2.protocol.sdk.Eccezione;
import org.openspcoop2.protocol.sdk.ProtocolException;
import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
import org.openspcoop2.protocol.sdk.validator.ValidazioneUtils;
import org.openspcoop2.utils.regexp.RegularExpressionEngine;

import com.fasterxml.jackson.databind.node.TextNode;

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

	private String claimName;
	private String v;
	private Object o;
	private ModIAuditClaimConfig modIAuditClaimConfig;
	
	// Usato in validazione
	public ModIValidazioneAuditClaimValue(String claimName, String v, Object o, ModIAuditClaimConfig modIAuditClaimConfig){
		this.claimName = claimName;
		this.v = v;
		this.o = o;
		this.modIAuditClaimConfig = modIAuditClaimConfig;
	}
	// Usato in imbustamento
	public ModIValidazioneAuditClaimValue(String claimName, String v, ModIAuditClaimConfig modIAuditClaimConfig, String prefix) throws ProtocolException{
		this.claimName = claimName;
		this.v = v;
		this.modIAuditClaimConfig = modIAuditClaimConfig;
		
		this.parseValue(prefix);
	}
	
	public String getValore() {
		return this.v;
	}
	public Object getRawObject() {
		return this.o;
	}
	
	private String getPrefixInvalidFormatValue() {
		return "Invalid format value '"+this.v+"'; ";
	}
	
	private void parseValue(String prefix) throws ProtocolException {
		if(this.modIAuditClaimConfig.isStringType()) {
			this.o = this.v;
		}
		else {
			if("true".equals(this.v)) {
				this.o = true;
			}
			else if("false".equals(this.v)) {
				this.o = false;
			}
			else {
				String expected = "";
				try {
					if(this.v.contains(".")) {
						expected = "double";
						double d = Double.parseDouble(this.v);
						this.o = d;
					}
					else {
						expected = "long";
						long l = Long.parseLong(this.v);
						this.o = l;
					}
				}catch(Exception e) {
					String msgErrore = prefix+ModIValidazioneSintatticaRest.getErroreTokenClaimNonValido(this.claimName, 
							new Exception(getPrefixInvalidFormatValue()+"expected "+expected+" primitive type"));
					processException(null, null, msgErrore, e);
				}
			}
		}
	}
	
	public void validate(String prefix) throws ProtocolException {
		this.validate(null, null, prefix);
	}
	public void validate(ValidazioneUtils validazioneUtils, List<Eccezione> erroriValidazione, String prefix) throws ProtocolException {
		
		validateValueType(validazioneUtils, erroriValidazione, prefix);
		
		validateValueLength(validazioneUtils, erroriValidazione, prefix);

		validateValueRegexp(validazioneUtils, erroriValidazione, prefix);
		
		validateValueByEnum(validazioneUtils, erroriValidazione, prefix);
		
	}
	private void processException(ValidazioneUtils validazioneUtils, List<Eccezione> erroriValidazione, String msgErrore) throws ProtocolException {
		processException(validazioneUtils, erroriValidazione, msgErrore, null);
	}
	private void processException(ValidazioneUtils validazioneUtils, List<Eccezione> erroriValidazione, String msgErrore, Exception e) throws ProtocolException {
		if(validazioneUtils!=null) {
			erroriValidazione.add(validazioneUtils.newEccezioneValidazione(CodiceErroreCooperazione.MITTENTE_NON_PRESENTE, msgErrore));
		}
		else {
			if(e!=null) {
				throw new ProtocolException(msgErrore, e);
			}
			else {
				throw new ProtocolException(msgErrore);
			}
		}
	}
	private void validateValueType(ValidazioneUtils validazioneUtils, List<Eccezione> erroriValidazione, String prefix) throws ProtocolException {
		if(this.modIAuditClaimConfig.isStringType()) {
			if( !(this.o instanceof TextNode) && !(this.o instanceof String) ) {
				String msgErrore = prefix+ModIValidazioneSintatticaRest.getErroreTokenClaimNonValido(this.claimName, 
						new Exception(getPrefixInvalidFormatValue()+"expected string type, found '"+this.o.getClass().getName()+"'"));
				processException(validazioneUtils, erroriValidazione, msgErrore);
			}
		}else {
			if(this.o instanceof TextNode) {
				String msgErrore = prefix+ModIValidazioneSintatticaRest.getErroreTokenClaimNonValido(this.claimName, 
						new Exception(getPrefixInvalidFormatValue()+"expected primitive type, found string"));
				processException(validazioneUtils, erroriValidazione, msgErrore);
			}
		}
	}
	private void validateValueLength(ValidazioneUtils validazioneUtils, List<Eccezione> erroriValidazione, String prefix) throws ProtocolException {
		int lengthV = this.v!=null ? this.v.length() : 0;
		
		if(this.modIAuditClaimConfig.getMinLength()>0 && lengthV<this.modIAuditClaimConfig.getMinLength()) {
			String msgErrore = prefix+ModIValidazioneSintatticaRest.getErroreTokenClaimNonValido(this.claimName, 
					new Exception("Invalid value '"+this.v+"'; min length requirement '"+this.modIAuditClaimConfig.getMinLength()+"' not met"));
			processException(validazioneUtils, erroriValidazione, msgErrore);
		}
		
		if(this.modIAuditClaimConfig.getMaxLength()>0 && lengthV>this.modIAuditClaimConfig.getMaxLength()) {
			String msgErrore = prefix+ModIValidazioneSintatticaRest.getErroreTokenClaimNonValido(this.claimName,
					new Exception("Invalid value '"+this.v+"'; max length requirement '"+this.modIAuditClaimConfig.getMaxLength()+"' not met"));
			processException(validazioneUtils, erroriValidazione, msgErrore);
		}
	}
	private void validateValueRegexp(ValidazioneUtils validazioneUtils, List<Eccezione> erroriValidazione, String prefix) throws ProtocolException {
		if(this.modIAuditClaimConfig.getRegexp()!=null && StringUtils.isNotEmpty(this.modIAuditClaimConfig.getRegexp())) {
			try {
				if(!RegularExpressionEngine.isMatch(this.v, this.modIAuditClaimConfig.getRegexp())) {
					throw new ProtocolException("Validation by regexp '"+this.modIAuditClaimConfig.getRegexp()+"' failed: invalid value '"+this.v+"'");
				}
			}catch(Exception e) {
				String msgErrore = prefix+ModIValidazioneSintatticaRest.getErroreTokenClaimNonValido(this.claimName, e);
				processException(validazioneUtils, erroriValidazione, msgErrore, e);
			}
		}
	}
	private void validateValueByEnum(ValidazioneUtils validazioneUtils, List<Eccezione> erroriValidazione, String prefix) throws ProtocolException {
		if(this.modIAuditClaimConfig.getValues()!=null && !this.modIAuditClaimConfig.getValues().isEmpty() &&
				!this.modIAuditClaimConfig.getValues().contains(this.v)) {
			String msgErrore = prefix+ModIValidazioneSintatticaRest.getErroreTokenClaimNonValido(this.claimName, new Exception("Validation by enum-list failed: value '"+this.v+"' unknown"));
			processException(validazioneUtils, erroriValidazione, msgErrore);
		}
	}
}