aswi2020vldc-gitlab/src/main/java/vldc/aswi/validators/ConfigurationValidator.java @ b07f6ea7

package vldc.aswi.validators;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.NumberUtils;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
import vldc.aswi.domain.Assembly;
import vldc.aswi.domain.Configuration;
import vldc.aswi.domain.parameter.Parameter;
import vldc.aswi.domain.parameter.ParameterInConfiguration;
import vldc.aswi.service.SqlQueryManager;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

@Component
public class ConfigurationValidator implements Validator {

    /**
     * Validator for supporting this class.
     * @param aClass - Class.
     * @return true if sent class match Configuration class.
     */
    @Override
    public boolean supports(Class<?> aClass) {
        return Configuration.class.isAssignableFrom(aClass);
    }

    /**
     * Validates the given configuration object.
     * @param obj Configuration object to be validated.
     * @param errors Errors variable where errors are stored.
     */
    @Override
    public void validate(Object obj, Errors errors) {
        Configuration configuration = (Configuration) obj;

        List<ParameterInConfiguration> parametersInConfiguration = configuration.getParametersInConfiguration();
        for (int i = 0; i < parametersInConfiguration.size(); i++) {
            ParameterInConfiguration parameterInConfiguration = parametersInConfiguration.get(i);
            if (parameterInConfiguration.getOperator() == null || parameterInConfiguration.getOperatorValue() == null ||
                    parameterInConfiguration.getOperatorValue().equals("")) {
                continue;
            }
            if (parameterInConfiguration.getOperator().getName().equals("BETWEEN") ||
                    parameterInConfiguration.getOperator().getName().equals("NOT BETWEEN")) {
                validateBETWEEN(parameterInConfiguration, errors, i, parameterInConfiguration.getOperator().getName());
            }
            else if (parameterInConfiguration.getOperator().getName().equals("IN") ||
                    parameterInConfiguration.getOperator().getName().equals("NOT IN")) {
                validateIN(parameterInConfiguration, errors, i, parameterInConfiguration.getOperator().getName());
            }
            else if (!parameterInConfiguration.getOperator().getName().equals("LIKE") ||
                    parameterInConfiguration.getOperator().getName().equals("NOT LIKE")) {
                validateOthersExceptLIKE(parameterInConfiguration, errors, i, parameterInConfiguration.getOperator().getName());
            }
        }

    }

    /**
     * Validates BETWEEN and NOT BETWEEN operator.
     * @param parameterInConfiguration Parameter in configuration to be validated.
     * @param errors Errors variable where errors are stored.
     * @param i Index of the parameter.
     * @param operator Operator of the parameter in configuration.
     */
    private void validateBETWEEN(ParameterInConfiguration parameterInConfiguration, Errors errors, int i, String operator) {
        if (!parameterInConfiguration.getOperatorValue().matches("\\w+;\\w+")) {
            errors.rejectValue("parametersInConfiguration[" + i + "].operatorValue", "Nesprávně oddělené hodnoty" +
                    " filtru " + operator +"! Použijte ';' pro oddělení hodnot!");
        }
        else {
            validateValuesInList(parameterInConfiguration, errors, i, operator);
        }
    }

    /**
     * Validates values in list.
     * @param parameterInConfiguration Parameter in configuration to be validated.
     * @param errors Errors variable where errors are stored.
     * @param i Index of the parameter.
     * @param operator Operator of the parameter in configuration.
     */
    private void validateValuesInList(ParameterInConfiguration parameterInConfiguration, Errors errors, int i, String operator) {
        String[] values = parameterInConfiguration.getOperatorValue().split(";");
        for (String value : values) {
            if (parameterInConfiguration.getParameter().getParameterType().getName().equals("Datum")) {
                validateDate(value, errors, i, operator);
            }
            if (parameterInConfiguration.getParameter().getParameterType().getName().equals("Číslo")) {
                validateNumber(value, errors, i, operator);
            }
        }
    }

    /**
     * Validates IN and NOT IN operator.
     * @param parameterInConfiguration Parameter in configuration to be validated.
     * @param errors Errors variable where errors are stored.
     * @param i Index of the parameter.
     * @param operator Operator of the parameter in configuration.
     */
    private void validateIN(ParameterInConfiguration parameterInConfiguration, Errors errors, int i, String operator) {
        if (!parameterInConfiguration.getOperatorValue().matches("\\w+(;\\w+)*$")) {
            errors.rejectValue("parametersInConfiguration[" + i + "].operatorValue", "Špatně zadaná hodnota" +
                    " filtru " + operator + "!  Použijte ';' pro oddělení hodnot!");
        }
        else {
            validateValuesInList(parameterInConfiguration, errors, i, operator);
        }
    }

    /**
     * Validates other operators.
     * @param parameterInConfiguration Parameter in configuration to be validated.
     * @param errors Errors variable where errors are stored.
     * @param i Index of the parameter.
     * @param operator Operator of the parameter in configuration.
     */
    private void validateOthersExceptLIKE(ParameterInConfiguration parameterInConfiguration, Errors errors, int i, String operator) {
        if (parameterInConfiguration.getParameter().getParameterType().getName().equals("Datum")) {
            validateDate(parameterInConfiguration.getOperatorValue(), errors, i, operator);
        }
        if (parameterInConfiguration.getParameter().getParameterType().getName().equals("Číslo")) {
            validateNumber(parameterInConfiguration.getOperatorValue(), errors, i, operator);
        }
    }

    /**
     * Validates numeric value.
     * @param value Value to be validated.
     * @param errors Errors variable where errors are stored.
     * @param i Index of hte parameter.
     * @param operator operator Operator of the parameter in configuration.
     */
    private void validateNumber(String value, Errors errors, int i, String operator) {
        if (!value.matches("-?\\d+(\\.\\d+)?")) {
            errors.rejectValue("parametersInConfiguration[" + i + "].operatorValue", "Špatně zadaná hodnota" +
                    " filtru " + operator + "! Očekává se číslo!");
        }
    }

    /**
     * Validates date value.
     * @param value Value to be validated.
     * @param errors Errors variable where errors are stored.
     * @param i Index of hte parameter.
     * @param operator operator Operator of the parameter in configuration.
     */
    private void validateDate(String value, Errors errors, int i, String operator) {
        try {
            new SimpleDateFormat("yyyy-MM-dd").parse(value);
        } catch (ParseException nfe) {
            errors.rejectValue("parametersInConfiguration[" + i + "].operatorValue", "Špatně zadaná hodnota" +
                    " filtru " + operator + "! Očekává se datum!");
        }
    }
}