EnumPresentRule validator (commit for test)

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/ValidationConfig.java

@@ -0,0 +1,63 @@
+package ru.spcex.clearing.scheduler.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.AccountBalance;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
+import ru.clearing.platform.dictionary.TaskDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerNewRequest;
+import ru.spcex.clearing.scheduler.validation.rules.EnumPresentRule;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Configuration
+public class ValidationConfig {
+    private final Map<String, Imdg<? extends SpcexObjectBase>> imdgs;
+
+    public ValidationConfig(ImdgProvider imdgProvider) {
+        this.imdgs = new HashMap<>();
+        BiConsumer<String, Class<? extends SpcexObjectBase>> addImdg = (s, aClass) -> imdgs.put(s, imdgProvider.getImdg(s, aClass));
+        addImdg.accept(IMDGDistributedNames.Map_Account, Account.class);
+        addImdg.accept(IMDGDistributedNames.Map_Company, Company.class);
+        addImdg.accept(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
+        addImdg.accept(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
+    }
+
+    /**
+     * чтобы во всех валидаторах был один экземпляр Imdg
+     */
+    private Imdg<?> getImdg(String key) {
+        return imdgs.get(key);
+    }
+
+    @Bean("plannerNewRequestValidator")
+    public Function<PlannerNewRequest, IValidator> plannerNewRequestValidator() {
+        return plannerNewRequest -> {
+            ImdgValidationContext<PlannerNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(plannerNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, getImdg(s));
+            addImdg.accept(IMDGDistributedNames.Map_TaskDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
+            return new ValidatorImpl<>(context,
+                    EnumPresentRule.instance("task",
+                            PlannerNewRequest::getTask,
+                            IMDGDistributedNames.Map_TaskDictionary,
+                            TaskDictionary.class)
+            );
+        };
+    }
+
+}

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/error/Errors.java

@@ -0,0 +1,21 @@
+package ru.spcex.clearing.scheduler.error;
+
+import ru.spcex.platform.utils.enumeration.IEnumId;
+
+public enum Errors implements IEnumId {
+    WrongFieldValue(10003L)
+
+    ;
+
+    private final Long id;
+
+    Errors(Long id) {
+        this.id = id;
+    }
+
+
+    @Override
+    public Long getId() {
+        return null;
+    }
+}

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/validation/rules/EnumPresentRule.java

@@ -0,0 +1,48 @@
+package ru.spcex.clearing.scheduler.validation.rules;
+
+import ru.spcex.clearing.scheduler.error.Errors;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidationRule;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+public class EnumPresentRule<T, D extends SpcexObjectBase> implements IValidationRule<ImdgValidationContext<T>> {
+    protected final Function<T, String> getEnumCode;
+    protected final String dictionaryName;
+    protected final String fieldName;
+    protected final Class<D> enumClass;
+
+    public EnumPresentRule(String fieldName, Function<T, String> getEnumCode, String dictionaryName, Class<D> enumClass) {
+        this.fieldName = fieldName;
+        this.getEnumCode = getEnumCode;
+        this.dictionaryName = dictionaryName;
+        this.enumClass = enumClass;
+    }
+
+    public static <T1, D1 extends SpcexObjectBase> EnumPresentRule<T1, D1> instance(String fieldName,
+                                                                                    Function<T1, String> getEnumCode,
+                                                                                    String dictionaryName,
+                                                                                    Class<D1> enumClass) {
+        return new EnumPresentRule<>(fieldName, getEnumCode, dictionaryName, enumClass);
+    }
+
+    @Override
+    public Optional<EnumMessage> validate(ImdgValidationContext<T> context) {
+        T validatedObject = context.getValidatedObject();
+        String enumCode = getEnumCode.apply(validatedObject);
+        Imdg<D> dictImdg = context.obtainMap(
+                dictionaryName,
+                enumClass
+        );
+        D taskFromMap = dictImdg.getSingleObjectByFieldValues(Map.of("code", enumCode));
+        if (taskFromMap == null) {
+            return of(Errors.WrongFieldValue, fieldName);
+        }
+        return empty();
+    }
+}