Abacus/src/main/java/com/abacus/evaluation/validate/ExpressionValidator.java at master · pranjal710/Abacus · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package com.abacus.evaluation.validate;

import com.abacus.evaluation.annotation.ValidateExpression;
import com.abacus.evaluation.utils.ArithmeticUtils;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExpressionValidator implements ConstraintValidator<ValidateExpression, String> {

    private final static Logger LOGGER = LoggerFactory.getLogger(ExpressionValidator.class);

    @Override
    public void initialize(ValidateExpression constraintAnnotation) {
    }

    @Override
    public boolean isValid(String input, ConstraintValidatorContext context) {
        context.disableDefaultConstraintViolation();
        if (!validSize(input, context) || !containsValidCharacters(input, context)
                || !correctPlacementOfBracesAndOperators(input, context)) {
            context
                    .buildConstraintViolationWithTemplate("InValid String!")
                    .addConstraintViolation();
            return false;
        }
        context
                .buildConstraintViolationWithTemplate("Valid String!")
                .addConstraintViolation();
        return true;
    }

    private boolean correctPlacementOfBracesAndOperators(String input, ConstraintValidatorContext context) {
        int left = 0, right = 0;
        for (int index = 0; index < input.length(); index++) {
            String curr = String.valueOf(input.charAt(index));
            if (ArithmeticUtils.isOperator(curr)) {
                if ((index > 0 && ArithmeticUtils.isOperator(String.valueOf(input.charAt(index - 1)))) || index == input.length()-1) {
                    LOGGER.debug("Incorrect operator placement!");
                    context
                            .buildConstraintViolationWithTemplate("Incorrect operator placement!")
                            .addConstraintViolation();
                    return false;
                }
            } else if (ArithmeticUtils.isClosingBracket(curr)) {
                right++;
                if (right > left ||
                        (index > 0 && (!ArithmeticUtils.isNumber(String.valueOf(input.charAt(index - 1))) && !ArithmeticUtils.isClosingBracket(String.valueOf(input.charAt(index - 1)))))
                ) {
                    LOGGER.debug("Incorrect placement close bracket!");
                    context
                            .buildConstraintViolationWithTemplate("Incorrect placement close bracket!")
                            .addConstraintViolation();
                    return false;
                }
            } else if (ArithmeticUtils.isStartBracket(curr)) {
                left++;
                if (right > left ||
                        (index > 0 && (!ArithmeticUtils.isOperator(String.valueOf(input.charAt(index - 1))) && !ArithmeticUtils.isStartBracket(String.valueOf(input.charAt(index - 1)))))
                ) {
                    LOGGER.debug("Incorrect placement start bracket!");
                    context
                            .buildConstraintViolationWithTemplate("Incorrect placement start bracket!")
                            .addConstraintViolation();
                    return false;
                }
            } else if (ArithmeticUtils.isNumber(curr)) {
                if (index > 0 && ArithmeticUtils.isClosingBracket(String.valueOf(input.charAt(index - 1)))) {
                    LOGGER.debug("Incorrect placement of number!");
                    context
                            .buildConstraintViolationWithTemplate("Incorrect placement of number!")
                            .addConstraintViolation();
                    return false;
                }
            } else if (ArithmeticUtils.isDecimal(curr)) {
                if (index == 0 || index == input.length()-1 || !ArithmeticUtils.isNumber(String.valueOf(input.charAt(index - 1)))) {
                    LOGGER.debug("Incorrect placement of decimal!");
                    context
                            .buildConstraintViolationWithTemplate("Incorrect placement of decimal!")
                            .addConstraintViolation();
                    return false;
                }
            }
        }

            if (left != right) {
                LOGGER.debug("Incorrect braces count!");
                context
                        .buildConstraintViolationWithTemplate("Incorrect braces count!")
                        .addConstraintViolation();
                return false;
            }
            return true;
        }

        private boolean containsValidCharacters (String input, ConstraintValidatorContext context){
            for (char ch : input.toCharArray()) {
                String curr = String.valueOf(ch);
                if (!ArithmeticUtils.isClosingBracket(curr)
                        && !ArithmeticUtils.isStartBracket(curr)
                        && !ArithmeticUtils.isNumber(curr)
                        && !ArithmeticUtils.isOperator(curr)
                        && !ArithmeticUtils.isDecimal(curr)
                ) {
                    context.buildConstraintViolationWithTemplate("Expression contains invalid characters!")
                            .addConstraintViolation();
                    LOGGER.debug("Expression contains invalid characters!");
                    return false;
                }
            }
            return true;
        }

        private boolean validSize (String input, ConstraintValidatorContext context){
            if (StringUtils.isEmpty(input)) {
                context.buildConstraintViolationWithTemplate("Expression cannot be of 0 length")
                        .addConstraintViolation();
                LOGGER.debug("Expression cannot be of 0 length");
                return false;
            }
            return true;
        }
    }