Now FastCGI server can validate user's input

server/src/main/java/org/validator/ValidatedRecordFactory.java

@@ -0,0 +1,22 @@
+package org.validator;
+
+import org.validator.validation.ValidationController;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+public class ValidatedRecordFactory {
+    @SuppressWarnings("unchecked")
+    public static <T extends Record> T create(Class<T> recordClass, Object... args) {
+        try {
+            Constructor<T> constructor = (Constructor<T>) recordClass.getDeclaredConstructors()[0];
+            T record = constructor.newInstance(args);
+
+            ValidationController.validateObject(record);
+
+            return record;
+        } catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
+            throw new RuntimeException("Record can't be created", e);
+        }
+    }
+}

server/src/main/java/org/validator/annotations/NotNull.java

@@ -0,0 +1,12 @@
+package org.validator.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.RECORD_COMPONENT, ElementType.ANNOTATION_TYPE})
+public @interface NotNull {
+    String errorMsg() default "Field required";
+}

server/src/main/java/org/validator/annotations/Number.java

@@ -0,0 +1,19 @@
+package org.validator.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE})
+@NotNull(errorMsg = "Number field is required")
+@Size(min = 1, errorMsg = "Number must not be empty")
+@Pattern(pattern = "^-?\\d+(\\.\\d+)?$", errorMsg = "Must be a valid number")
+public @interface Number {
+    String rangeErrorMsg() default "Number must be between %s and %s";
+    String stepErrorMsg() default "Number distance from minimum must be divisible by %s";
+    double min() default Integer.MIN_VALUE;
+    double max() default Integer.MAX_VALUE;
+    double step() default 0;
+}

server/src/main/java/org/validator/annotations/Pattern.java

@@ -0,0 +1,14 @@
+package org.validator.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.RECORD_COMPONENT, ElementType.ANNOTATION_TYPE})
+@NotNull
+public @interface Pattern {
+    String errorMsg() default "Pattern mismatch";
+    String pattern();
+}

server/src/main/java/org/validator/annotations/Size.java

@@ -0,0 +1,15 @@
+package org.validator.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.RECORD_COMPONENT, ElementType.ANNOTATION_TYPE})
+@NotNull
+public @interface Size {
+    String errorMsg() default "String size must be between %d and %d";
+    int min() default 0;
+    long max() default Integer.MAX_VALUE;
+}

server/src/main/java/org/validator/validation/ValidationController.java

@@ -0,0 +1,54 @@
+package org.validator.validation;
+
+import org.validator.annotations.*;
+import org.validator.annotations.Number;
+import org.validator.validation.validators.*;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.HashMap;
+
+public class ValidationController {
+
+    private static final HashMap<Class<?>, Validator<? extends Annotation>> validatorCache = new HashMap<>();
+
+    static {
+        validatorCache.put(NotNull.class, new NotNullValidator());
+        validatorCache.put(Size.class, new SizeValidator());
+        validatorCache.put(Pattern.class, new PatternValidator());
+        validatorCache.put(Number.class, new NumberValidator());
+    }
+
+    public static <T> void validateObject(T object) {
+        for (Field field : object.getClass().getDeclaredFields()) {
+            try {
+                field.setAccessible(true);
+
+                Object value = field.get(object);
+                validateField(value, field.getAnnotations());
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException("Failed to validate field: " + field.getName(), e);
+            }
+        }
+    }
+
+    private static <T extends Annotation> void validateField(Object value, T[] annotations) {
+        for (Annotation annotation : annotations) {
+            validateAnnotation(annotation, value);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void validateAnnotation(Annotation annotation, Object value) {
+        Class<? extends Annotation> annotationType = annotation.annotationType();
+
+        Validator<Annotation> validator = (Validator<Annotation>) validatorCache.get(annotationType);
+        if (validator == null) return;
+
+        for (Annotation metaAnnotation : annotationType.getAnnotations()) validateAnnotation(metaAnnotation, value);
+
+        validator.validate(annotation, value);
+    }
+}
+
+

server/src/main/java/org/validator/validation/exceptions/ValidationException.java

@@ -0,0 +1,7 @@
+package org.validator.validation.exceptions;
+
+public class ValidationException extends RuntimeException {
+    public ValidationException(String message) {
+        super(message);
+    }
+}

server/src/main/java/org/validator/validation/validators/NotNullValidator.java

@@ -0,0 +1,13 @@
+package org.validator.validation.validators;
+
+import org.validator.annotations.NotNull;
+import org.validator.validation.exceptions.ValidationException;
+
+public class NotNullValidator implements Validator<NotNull> {
+    @Override
+    public void validate(NotNull annotation, Object value) {
+        if (value == null) {
+            throw new ValidationException(annotation.errorMsg());
+        }
+    }
+}

server/src/main/java/org/validator/validation/validators/NumberValidator.java

@@ -0,0 +1,23 @@
+package org.validator.validation.validators;
+
+import org.validator.annotations.Number;
+import org.validator.validation.exceptions.ValidationException;
+
+public class NumberValidator implements Validator<Number> {
+    @Override
+    public void validate(Number annotation, Object value) {
+        if (value instanceof String str) {
+            double num = Double.parseDouble(str);
+            if (num < annotation.min() || num > annotation.max()) {
+                throw new ValidationException(
+                        String.format(annotation.rangeErrorMsg(), annotation.min(), annotation.max())
+                );
+            }
+            if (annotation.step() != 0 && (num-annotation.min())%annotation.step() != 0) {
+                throw new ValidationException(
+                        String.format(annotation.stepErrorMsg(), annotation.step())
+                );
+            }
+        }
+    }
+}

server/src/main/java/org/validator/validation/validators/PatternValidator.java

@@ -0,0 +1,15 @@
+package org.validator.validation.validators;
+
+import org.validator.annotations.Pattern;
+import org.validator.validation.exceptions.ValidationException;
+
+public class PatternValidator implements Validator<Pattern> {
+    @Override
+    public void validate(Pattern annotation, Object value) {
+        if (value instanceof String str) {
+            if (!str.matches(annotation.pattern())) {
+                throw new ValidationException(annotation.errorMsg());
+            }
+        }
+    }
+}

server/src/main/java/org/validator/validation/validators/SizeValidator.java

@@ -0,0 +1,21 @@
+package org.validator.validation.validators;
+
+import org.validator.annotations.Size;
+import org.validator.validation.exceptions.ValidationException;
+
+public class SizeValidator implements Validator<Size> {
+    @Override
+    public void validate(Size annotation, Object value) {
+        if (value instanceof String str) {
+            if (str.length() < annotation.min() || str.length() > annotation.max()) {
+                throw new ValidationException(
+                        String.format(
+                                annotation.errorMsg(),
+                                annotation.min(),
+                                annotation.max()
+                        )
+                );
+            }
+        }
+    }
+}

server/src/main/java/org/validator/validation/validators/Validator.java

@@ -0,0 +1,7 @@
+package org.validator.validation.validators;
+import java.lang.annotation.Annotation;
+
+@FunctionalInterface
+public interface Validator<A extends Annotation> {
+    void validate(A annotation, Object value);
+}

server/src/main/java/org/web1/DTOs/RequestDTO.java

@@ -0,0 +1,9 @@
+package org.web1.DTOs;
+
+import org.validator.annotations.Number;
+
+public record RequestDTO(
+        @Number(min = -4, max = 4, step = 1) String X,
+        @Number(min = 1, max = 3, step = 0.5) String R,
+        @Number(min = -3, max = 5) String Y
+) {}

server/src/main/java/org/web1/Main.java

@@ -4,12 +4,15 @@
 import java.util.HashMap;
 import java.util.function.Function;
 
+import org.validator.ValidatedRecordFactory;
+import org.validator.validation.exceptions.ValidationException;
+import org.web1.DTOs.RequestDTO;
 import org.web1.checkers.Checker;
 import org.web1.checkers.CheckerFunction;
-import org.web1.utils.JsonBuilder;
-import org.web1.utils.QueryStringToHashmap;
-import org.web1.utils.ResponseController;
-import org.web1.utils.Timer;
+import org.web1.netUtils.JsonBuilder;
+import org.web1.netUtils.QueryStringToHashmap;
+import org.web1.netUtils.ResponseFactory;
+import org.web1.timer.Timer;
 
 public class Main {
     private static final Function<String, HashMap<String,String>> parseQuery = new QueryStringToHashmap();
@@ -22,18 +25,37 @@ public static void main(String[] args) {
         while (fastCGI.FCGIaccept() >= 0) {
             timer.start();
 
-            HashMap<String, String> queryParams = parseQuery.apply(
+            final HashMap<String, String> queryParams = parseQuery.apply(
                     FCGIInterface.request.params.getProperty("QUERY_STRING")
             );
-            boolean checkResult = checker.test(queryParams);
 
-            String result = ResponseController.create(
-                    new JsonBuilder()
-                            .add("result", checkResult)
-                            .add("elapsedTimeNs", timer.stop())
-            );
-
-            System.out.println(result);
+            try {
+                RequestDTO requestData = ValidatedRecordFactory.create(
+                        RequestDTO.class,
+                        queryParams.get("x"),
+                        queryParams.get("r"),
+                        queryParams.get("y")
+                );
+
+                boolean checkResult = checker.test(
+                        Integer.parseInt(requestData.X()),
+                        Float.parseFloat(requestData.Y()),
+                        Float.parseFloat(requestData.R())
+                );
+
+                String result = ResponseFactory.create(
+                        new JsonBuilder()
+                                .add("result", checkResult)
+                                .add("elapsedTimeNs", timer.stop())
+                );
+
+                System.out.println(result);
+            } catch (ValidationException e) {
+                String result = ResponseFactory.create(
+                        new JsonBuilder().add("error", '"'+e.getMessage()+'"')
+                );
+                System.out.println(result);
+            }
         }
     }
 }

server/src/main/java/org/web1/checkers/Checker.java

@@ -5,11 +5,7 @@
 import java.util.HashMap;
 
 public class Checker implements CheckerFunction{
-    public boolean test(HashMap<String, String> data) {
-        int x = Integer.parseInt(data.get("x"));
-        float y = Float.parseFloat(data.get("y"));
-        float r = Float.parseFloat(data.get("r"));
-
+    public boolean test(int x, float y, float r) {
         final GraphQuarters quarter = GraphUtils.getQuarter(x, y);
 
         if (quarter == GraphQuarters.FIRST_QUADRANT) return firstQuarterTester(x, y, r);

server/src/main/java/org/web1/checkers/CheckerFunction.java

@@ -4,5 +4,5 @@
 
 @FunctionalInterface
 public interface CheckerFunction {
-    boolean test(HashMap<String, String> data);
+    boolean test(int x, float y, float r);
 }

server/src/main/java/org/web1/utils/JsonBuilder.java → server/src/main/java/org/web1/netUtils/JsonBuilder.java

@@ -1,4 +1,4 @@
-package org.web1.utils;
+package org.web1.netUtils;
 
 import java.util.HashMap;
 

server/src/main/java/org/web1/utils/QueryStringToHashmap.java → server/src/main/java/org/web1/netUtils/QueryStringToHashmap.java

@@ -1,4 +1,4 @@
-package org.web1.utils;
+package org.web1.netUtils;
 
 import java.util.HashMap;
 import java.util.function.Function;

server/src/main/java/org/web1/utils/ResponseController.java → server/src/main/java/org/web1/netUtils/ResponseFactory.java

@@ -1,6 +1,6 @@
-package org.web1.utils;
+package org.web1.netUtils;
 
-public class ResponseController {
+public class ResponseFactory {
     private static final String BASE_RESPONSE = """
             Access-Control-Allow-Origin: *
             Connection: keep-alive

server/src/main/java/org/web1/utils/Timer.java → server/src/main/java/org/web1/timer/Timer.java

@@ -1,4 +1,4 @@
-package org.web1.utils;
+package org.web1.timer;
 
 public class Timer {
     long startTime;