PlannerTemplateServiceValidation

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

@@ -2,29 +2,11 @@ package ru.spcex.clearing.scheduler;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.context.ConfigurableApplicationContext;
-import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
-import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerNewRequest;
-import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
-import ru.spcex.clearing.scheduler.service.PlannerService;
 
 @SpringBootApplication
 public class SchedulerServiceApplication {
     public static void main(String[] args) {
         SpringApplication springApplication = new SpringApplication(SchedulerServiceApplication.class);
-        ConfigurableApplicationContext context = springApplication.run(args);
+        springApplication.run(args);
-        PlannerService plannerService = context.getBean(PlannerService.class);
-        try {
-            Thread.sleep(100000);
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-        var baseRequest = new BaseRequest<PlannerNewRequest>();
-        var plannerNewRequest = new PlannerNewRequest();
-        plannerNewRequest.task = "GBAL";
-        baseRequest.setId(777L);
-        baseRequest.setRequestPayload(plannerNewRequest);
-        RequestInfoUpdate requestInfoUpdate = plannerService.newScheduler(baseRequest);
-        System.out.println(requestInfoUpdate.toString());
     }
 }

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

@@ -1,85 +0,0 @@
-package ru.spcex.clearing.scheduler.config;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import ru.clearing.classes.statics.data.company.Company;
-import ru.clearing.classes.statics.data.security.Security;
-import ru.clearing.platform.dictionary.TaskDictionary;
-import ru.clearing.platform.dictionary.TaskStatusDictionary;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerNewRequest;
-import ru.spcex.clearing.scheduler.error.ValidationError;
-import ru.spcex.clearing.scheduler.validation.rules.common.*;
-import ru.spcex.platform.classes.base.SpcexObjectBase;
-import ru.spcex.platform.enumeration.Market;
-import ru.spcex.platform.enumeration.WorkflowStatus;
-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_TaskDictionary, TaskDictionary.class);
-        addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class);
-        addImdg.accept(IMDGDistributedNames.Map_Company, Company.class);
-        addImdg.accept(IMDGDistributedNames.Map_Security, Security.class);
-    }
-
-    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);
-            return new ValidatorImpl<>(context,
-                    DictionaryPresentRule.instance("task",
-                            PlannerNewRequest::getTask,
-                            IMDGDistributedNames.Map_TaskDictionary,
-                            TaskDictionary.class),
-                    TimeNotBeforeRule.instance("taskTime",
-                            PlannerNewRequest::getTaskTime),
-                    DateNotBeforeRule.instance("clearingDate",
-                            PlannerNewRequest::getClearingDate),
-                    EnumPresentRule.instance("market",
-                            PlannerNewRequest::getMarket,
-                            Market.values(),
-                            false),
-                    DictionaryPresentRule.instance("taskStatus",
-                            PlannerNewRequest::getTaskStatus,
-                            IMDGDistributedNames.Map_TaskStatusDictionary,
-                            TaskStatusDictionary.class),
-                    IdPresentRule.instance("companyId",
-                            PlannerNewRequest::getCompanyId,
-                            IMDGDistributedNames.Map_Company,
-                            Company.class,
-                            ValidationError.CompanyNotFound,
-                            company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
-                    IdPresentRule.instance("securityId",
-                            PlannerNewRequest::getSecurityId,
-                            IMDGDistributedNames.Map_Security,
-                            Security.class,
-                            ValidationError.SecurityNotFound,
-                            security -> WorkflowStatus.Active.getKey().equals(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)
-            );
-        };
-    }
-
-}

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

@@ -0,0 +1,115 @@
+package ru.spcex.clearing.scheduler.config.validation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.scheduler.PlannerTemplate;
+import ru.clearing.classes.statics.data.security.Security;
+import ru.clearing.platform.dictionary.TaskDictionary;
+import ru.clearing.platform.dictionary.TaskStatusDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateUpdateRequest;
+import ru.spcex.clearing.scheduler.error.ValidationError;
+import ru.spcex.clearing.scheduler.validation.rules.common.DictionaryPresentRule;
+import ru.spcex.clearing.scheduler.validation.rules.common.IdPresentRule;
+import ru.spcex.clearing.scheduler.validation.rules.common.TimeNotBeforeRule;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Configuration
+public class PlannerTemplateValidationConfig {
+
+    @Bean("plannerTemplateNewRequestValidator")
+    public Function<PlannerTemplateNewRequest, IValidator> plannerNewRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return plannerNewRequest -> {
+            ImdgValidationContext<PlannerTemplateNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(plannerNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_TaskDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_Security);
+            return new ValidatorImpl<>(context,
+                    DictionaryPresentRule.instance("task",
+                            PlannerTemplateNewRequest::getTask,
+                            IMDGDistributedNames.Map_TaskDictionary,
+                            TaskDictionary.class),
+                    TimeNotBeforeRule.instance("taskTime",
+                            PlannerTemplateNewRequest::getTaskTime),
+                    DictionaryPresentRule.instance("taskStatus",
+                            PlannerTemplateNewRequest::getTaskStatus,
+                            IMDGDistributedNames.Map_TaskStatusDictionary,
+                            TaskStatusDictionary.class),
+                    IdPresentRule.instance("companyId",
+                            PlannerTemplateNewRequest::getCompanyId,
+                            IMDGDistributedNames.Map_Company,
+                            Company.class,
+                            ValidationError.CompanyNotFound,
+                            company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
+                    IdPresentRule.instance("securityId",
+                            PlannerTemplateNewRequest::getSecurityId,
+                            IMDGDistributedNames.Map_Security,
+                            Security.class,
+                            ValidationError.SecurityNotFound,
+                            security -> WorkflowStatus.Active.getKey().equals(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)
+            );
+        };
+    }
+
+    @Bean("plannerTemplateUpdateRequestValidator")
+    public Function<PlannerTemplateUpdateRequest, IValidator> plannerUpdateRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return plannerUpdateRequest -> {
+            ImdgValidationContext<PlannerTemplateUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(plannerUpdateRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_TaskDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_Security);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            PlannerTemplateUpdateRequest::getId,
+                            IMDGDistributedNames.Map_PlannerTemplate,
+                            PlannerTemplate.class,
+                            ValidationError.WrongUpdate),
+                    DictionaryPresentRule.instance("task",
+                            PlannerTemplateNewRequest::getTask,
+                            IMDGDistributedNames.Map_TaskDictionary,
+                            TaskDictionary.class,
+                            false),
+                    TimeNotBeforeRule.instance("taskTime",
+                            PlannerTemplateNewRequest::getTaskTime,
+                            false),
+                    DictionaryPresentRule.instance("taskStatus",
+                            PlannerTemplateNewRequest::getTaskStatus,
+                            IMDGDistributedNames.Map_TaskStatusDictionary,
+                            TaskStatusDictionary.class,
+                            false),
+                    IdPresentRule.instance("companyId",
+                            PlannerTemplateNewRequest::getCompanyId,
+                            IMDGDistributedNames.Map_Company,
+                            Company.class,
+                            ValidationError.CompanyNotFound,
+                            false,
+                            company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
+                    IdPresentRule.instance("securityId",
+                            PlannerTemplateNewRequest::getSecurityId,
+                            IMDGDistributedNames.Map_Security,
+                            Security.class,
+                            ValidationError.SecurityNotFound,
+                            false,
+                            security -> WorkflowStatus.Active.getKey().equals(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)
+            );
+        };
+    }
+
+}

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

@@ -0,0 +1,127 @@
+package ru.spcex.clearing.scheduler.config.validation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.scheduler.Planner;
+import ru.clearing.classes.statics.data.security.Security;
+import ru.clearing.platform.dictionary.TaskDictionary;
+import ru.clearing.platform.dictionary.TaskStatusDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerUpdateRequest;
+import ru.spcex.clearing.scheduler.error.ValidationError;
+import ru.spcex.clearing.scheduler.validation.rules.common.*;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.enumeration.Market;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Configuration
+public class PlannerValidationConfig {
+
+    @Bean("plannerNewRequestValidator")
+    public Function<PlannerNewRequest, IValidator> plannerNewRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return plannerNewRequest -> {
+            ImdgValidationContext<PlannerNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(plannerNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_TaskDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_Security);
+            return new ValidatorImpl<>(context,
+                    DictionaryPresentRule.instance("task",
+                            PlannerNewRequest::getTask,
+                            IMDGDistributedNames.Map_TaskDictionary,
+                            TaskDictionary.class),
+                    TimeNotBeforeRule.instance("taskTime",
+                            PlannerNewRequest::getTaskTime),
+                    DateNotBeforeRule.instance("clearingDate",
+                            PlannerNewRequest::getClearingDate),
+                    EnumPresentRule.instance("market",
+                            PlannerNewRequest::getMarket,
+                            Market.values(),
+                            false),
+                    DictionaryPresentRule.instance("taskStatus",
+                            PlannerNewRequest::getTaskStatus,
+                            IMDGDistributedNames.Map_TaskStatusDictionary,
+                            TaskStatusDictionary.class),
+                    IdPresentRule.instance("companyId",
+                            PlannerNewRequest::getCompanyId,
+                            IMDGDistributedNames.Map_Company,
+                            Company.class,
+                            ValidationError.CompanyNotFound,
+                            company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
+                    IdPresentRule.instance("securityId",
+                            PlannerNewRequest::getSecurityId,
+                            IMDGDistributedNames.Map_Security,
+                            Security.class,
+                            ValidationError.SecurityNotFound,
+                            security -> WorkflowStatus.Active.getKey().equals(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)
+            );
+        };
+    }
+
+    @Bean("plannerUpdateRequestValidator")
+    public Function<PlannerUpdateRequest, IValidator> plannerUpdateRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return plannerUpdateRequest -> {
+            ImdgValidationContext<PlannerUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(plannerUpdateRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_TaskDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_Security);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            PlannerUpdateRequest::getId,
+                            IMDGDistributedNames.Map_Planner,
+                            Planner.class,
+                            ValidationError.WrongUpdate),
+                    DictionaryPresentRule.instance("task",
+                            PlannerUpdateRequest::getTask,
+                            IMDGDistributedNames.Map_TaskDictionary,
+                            TaskDictionary.class,
+                            false),
+                    TimeNotBeforeRule.instance("taskTime",
+                            PlannerUpdateRequest::getTaskTime,
+                            false),
+                    DateNotBeforeRule.instance("clearingDate",
+                            PlannerUpdateRequest::getClearingDate,
+                            false),
+                    EnumPresentRule.instance("market",
+                            PlannerUpdateRequest::getMarket,
+                            Market.values(),
+                            false),
+                    DictionaryPresentRule.instance("taskStatus",
+                            PlannerUpdateRequest::getTaskStatus,
+                            IMDGDistributedNames.Map_TaskStatusDictionary,
+                            TaskStatusDictionary.class,
+                            false),
+                    IdPresentRule.instance("companyId",
+                            PlannerUpdateRequest::getCompanyId,
+                            IMDGDistributedNames.Map_Company,
+                            Company.class,
+                            ValidationError.CompanyNotFound,
+                            false,
+                            company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
+                    IdPresentRule.instance("securityId",
+                            PlannerUpdateRequest::getSecurityId,
+                            IMDGDistributedNames.Map_Security,
+                            Security.class,
+                            ValidationError.SecurityNotFound,
+                            false,
+                            security -> WorkflowStatus.Active.getKey().equals(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)
+            );
+        };
+    }
+
+}

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

@@ -0,0 +1,49 @@
+package ru.spcex.clearing.scheduler.config.validation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.security.Security;
+import ru.clearing.platform.dictionary.TaskDictionary;
+import ru.clearing.platform.dictionary.TaskStatusDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.scheduler.validation.rules.common.FieldRequiredRule;
+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.Function;
+
+@Configuration
+public class ValidationConfig {
+
+    @Bean("imdgForValidation")
+    public Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation(ImdgProvider imdgProvider) {
+        final Map<String, Imdg<? extends SpcexObjectBase>> imdg = new HashMap<>();
+        BiConsumer<String, Class<? extends SpcexObjectBase>> addImdg = (s, aClass) -> imdg.put(s, imdgProvider.getImdg(s, aClass));
+        addImdg.accept(IMDGDistributedNames.Map_TaskDictionary, TaskDictionary.class);
+        addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class);
+        addImdg.accept(IMDGDistributedNames.Map_Company, Company.class);
+        addImdg.accept(IMDGDistributedNames.Map_Security, Security.class);
+        return imdg;
+    }
+
+    @Bean("commonDeleteRequestValidator")
+    public Function<CommonDeleteRequest, IValidator> commonDeleteRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return commonDeleteRequest -> {
+            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(commonDeleteRequest);
+            return new ValidatorImpl<>(context,
+                    FieldRequiredRule.instance("id", CommonDeleteRequest::getId)
+            );
+        };
+    }
+
+}

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

@@ -6,6 +6,7 @@ public enum ValidationError implements IEnumId {
     WrongDictionaryValue(10003L),
     EmptyRequiredValue(10002L),
     WrongEnumValue(777L), //todo set code
+    WrongUpdate(666L), //todo set code
     TaskForPastDate(7010L),
     TaskForPastTime(7011L),
     CompanyNotFound(7014L),

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

@@ -18,7 +18,6 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerUpdateReq
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
 import ru.spcex.clearing.platform.messaging.service.Status;
-import ru.spcex.clearing.scheduler.validation.IRequestValidator;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
@@ -26,7 +25,6 @@ import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.validation.IValidator;
 
 import java.time.Instant;
-import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
 
@@ -36,20 +34,24 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
     private final ImdgProvider imdgProvider;
     private final Imdg<Planner> plannerMap;
     private final IMessageResolver messageResolver;
-    private final Function<PlannerNewRequest, IValidator> validationFactory;
+    private final Function<CommonDeleteRequest, IValidator> plannerDeleteRequestValidation;
-    private final IRequestValidator<PlannerUpdateRequest> plannerUpdateRequest = IRequestValidator.PLANNER_UPDATE_REQUEST;
+    private final Function<PlannerNewRequest, IValidator> plannerNewRequestValidation;
-    private final IRequestValidator<CommonDeleteRequest> deleteRequestValidator = IRequestValidator.COMMON_DELETE_REQUEST;
+    private final Function<PlannerUpdateRequest, IValidator> plannerUpdateRequestValidation;
 
     @Autowired
     public PlannerService(Consumer<String, Object> kafkaQueue,
                           Producer<String, Object> kafkaProducer,
                           ImdgProvider imdgProvider,
                           IMessageResolver messageResolver,
-                          @Qualifier("plannerNewRequestValidator") Function<PlannerNewRequest, IValidator> plannerNewRequestValidator) {
+                          @Qualifier("commonDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> plannerDeleteRequestValidator,
+                          @Qualifier("plannerNewRequestValidator") Function<PlannerNewRequest, IValidator> plannerNewRequestValidator,
+                          @Qualifier("plannerUpdateRequestValidator") Function<PlannerUpdateRequest, IValidator> plannerUpdateRequestValidator) {
         super(kafkaQueue, kafkaProducer);
         this.plannerMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Planner, Planner.class);
         this.messageResolver = messageResolver;
-        this.validationFactory = plannerNewRequestValidator;
+        this.plannerDeleteRequestValidation = plannerDeleteRequestValidator;
+        this.plannerNewRequestValidation = plannerNewRequestValidator;
+        this.plannerUpdateRequestValidation = plannerUpdateRequestValidator;
         this.imdgProvider = imdgProvider;
     }
 
@@ -59,26 +61,28 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
                 .setFunction(this::newScheduler)
                 .forDestination(Consts.DESTINATION_PLANNER_NEW, callbacks::put);
         callback(PlannerUpdateRequest.class)
-                .setConsumer(this::updateScheduler)
+                .setFunction(this::updateScheduler)
                 .forDestination(Consts.DESTINATION_PLANNER_UPDATE, callbacks::put);
         callback(CommonDeleteRequest.class)
-                .setConsumer(this::deleteScheduler)
+                .setFunction(this::deleteScheduler)
                 .forDestination(Consts.DESTINATION_PLANNER_DELETE, callbacks::put);
         init();
     }
 
-    public RequestInfoUpdate newScheduler(BaseRequest<PlannerNewRequest> userRequest) {
+    private RequestInfoUpdate newScheduler(BaseRequest<PlannerNewRequest> userRequest) {
         PlannerNewRequest req = userRequest.getRequestPayload();
         log.debug("PlannerNewRequest received");
-        IValidator validator = validationFactory.apply(req);
+        if (plannerNewRequestValidation != null) {
-        Optional<EnumMessage> validationError = validator.tillFirstError();
+            IValidator validator = plannerNewRequestValidation.apply(req);
-        if (validationError.isPresent()) {
+            Optional<EnumMessage> validationError = validator.tillFirstError();
-            String errorMsg = messageResolver.resolve(validationError.get());
+            if (validationError.isPresent()) {
-            log.error("cannot process PlannerNewRequest id={}: {}", userRequest.getId(), errorMsg);
+                String errorMsg = messageResolver.resolve(validationError.get());
-            return new RequestInfoUpdate()
+                log.error("cannot process PlannerNewRequest id={}: {}", userRequest.getId(), errorMsg);
-                    .setId(userRequest.getId())
+                return new RequestInfoUpdate()
-                    .setStatus(Status.Error)
+                        .setId(userRequest.getId())
-                    .setMessage(errorMsg);
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
         }
         Planner planner = new Planner();
         planner.setCreated(Instant.now());
@@ -94,11 +98,21 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
         return null;
     }
 
-    private void updateScheduler(BaseRequest<PlannerUpdateRequest> userRequest) {
+    private RequestInfoUpdate updateScheduler(BaseRequest<PlannerUpdateRequest> userRequest) {
         PlannerUpdateRequest req = userRequest.getRequestPayload();
         log.debug("PlannerUpdateRequest received id = {}", req.getId());
-        List<IRequestValidator.ValidationError> errors = plannerUpdateRequest.validate(req, imdgProvider);
+        if (plannerUpdateRequestValidation != null) {
-        if (IRequestValidator.checkErrorList(errors, log)) return;
+            IValidator validator = plannerUpdateRequestValidation.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process PlannerUpdateRequest id={}: {}", userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
         Planner planner = plannerMap.getSingleObjectByID(req.getId());
         planner.setUpdated(Instant.now());
         planner.setTask(req.getTask());
@@ -109,15 +123,27 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
         planner.setCompanyId(req.getCompanyId());
         planner.setSecurityId(req.getSecurityId());
         plannerMap.update(planner);
+        return null;
     }
 
-    private void deleteScheduler(BaseRequest<CommonDeleteRequest> userRequest) {
+    private RequestInfoUpdate deleteScheduler(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
         log.debug("CommonDeleteRequest received id = {}", req.getId());
-        List<IRequestValidator.ValidationError> errors = deleteRequestValidator.validate(req, imdgProvider);
+        if (plannerDeleteRequestValidation != null) {
-        if (IRequestValidator.checkErrorList(errors, log)) return;
+            IValidator validator = plannerDeleteRequestValidation.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process PlannerUpdateRequest id={}: {}", userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
         Planner planner = plannerMap.getSingleObjectByID(req.getId());
         plannerMap.delete(planner);
+        return null;
     }
 
 }

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

@@ -6,6 +6,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.scheduler.PlannerTemplate;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
@@ -15,49 +16,73 @@ import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteReques
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateUpdateRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
-import ru.spcex.clearing.scheduler.validation.IRequestValidator;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.platform.messaging.service.Status;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.validation.IValidator;
 
 import java.time.Instant;
-import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
 
 @Service
 public class PlannerTemplateService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final Imdg<PlannerTemplate> plannerTemplateMap;
     private final ImdgProvider imdgProvider;
-    private final IRequestValidator<PlannerTemplateNewRequest> plannerTemplateNewRequest = IRequestValidator.PLANNER_TEMPLATE_NEW_REQUEST;
+    private final IMessageResolver messageResolver;
-    private final IRequestValidator<PlannerTemplateUpdateRequest> plannerTemplateUpdateRequest = IRequestValidator.PLANNER_TEMPLATE_UPDATE_REQUEST;
+    private final Function<CommonDeleteRequest, IValidator> plannerTemplateDeleteRequestValidation;
-    private final IRequestValidator<CommonDeleteRequest> deleteRequestValidator = IRequestValidator.COMMON_DELETE_REQUEST;
+    private final Function<PlannerTemplateNewRequest, IValidator> plannerTemplateNewRequestValidation;
+    private final Function<PlannerTemplateUpdateRequest, IValidator> plannerTemplateUpdateRequestValidation;
 
     @Autowired
     public PlannerTemplateService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
-                                  ImdgProvider imdgProvider) {
+                                  ImdgProvider imdgProvider,
+                                  IMessageResolver messageResolver,
+                                  @Qualifier("commonDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> plannerTemplateDeleteRequestValidator,
+                                  @Qualifier("plannerTemplateNewRequestValidator") Function<PlannerTemplateNewRequest, IValidator> plannerTemplateNewRequestValidator,
+                                  @Qualifier("plannerTemplateUpdateRequestValidator") Function<PlannerTemplateUpdateRequest, IValidator> plannerTemplateUpdateRequestValidator) {
         super(kafkaQueue, kafkaProducer);
         this.plannerTemplateMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PlannerTemplate, PlannerTemplate.class);
         this.imdgProvider = imdgProvider;
+        this.plannerTemplateDeleteRequestValidation = plannerTemplateDeleteRequestValidator;
+        this.plannerTemplateNewRequestValidation = plannerTemplateNewRequestValidator;
+        this.plannerTemplateUpdateRequestValidation = plannerTemplateUpdateRequestValidator;
+        this.messageResolver = messageResolver;
     }
 
     @Override
     public void afterPropertiesSet() {
         callback(PlannerTemplateNewRequest.class)
-                .setConsumer(this::newTimetable)
+                .setFunction(this::newTimetable)
                 .forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_NEW, callbacks::put);
         callback(PlannerTemplateUpdateRequest.class)
-                .setConsumer(this::updateTimetable)
+                .setFunction(this::updateTimetable)
                 .forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_UPDATE, callbacks::put);
         callback(CommonDeleteRequest.class)
-                .setConsumer(this::deleteTimetable)
+                .setFunction(this::deleteTimetable)
                 .forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_DELETE, callbacks::put);
         init();
     }
 
-    private void newTimetable(BaseRequest<PlannerTemplateNewRequest> userRequest) {
+    private RequestInfoUpdate newTimetable(BaseRequest<PlannerTemplateNewRequest> userRequest) {
         PlannerTemplateNewRequest req = userRequest.getRequestPayload();
         log.debug("PlannerTemplateNewRequest received");
-        List<IRequestValidator.ValidationError> errors = plannerTemplateNewRequest.validate(req, imdgProvider);
+        if (plannerTemplateNewRequestValidation != null) {
-        if (IRequestValidator.checkErrorList(errors, log)) return;
+            IValidator validator = plannerTemplateNewRequestValidation.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process PlannerTemplateNewRequest id={}: {}", userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
         PlannerTemplate plannerTemplate = new PlannerTemplate();
         Instant created = Instant.now();
         plannerTemplate.setCreated(created);
@@ -68,14 +93,25 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
         plannerTemplate.setSecurityId(req.getSecurityId());
         plannerTemplateMap.insert(plannerTemplate);
         log.debug("successfully processed, new id {}", plannerTemplate.getId());
+        return null;
     }
 
-    private void updateTimetable(BaseRequest<PlannerTemplateUpdateRequest> userRequest) {
+    private RequestInfoUpdate updateTimetable(BaseRequest<PlannerTemplateUpdateRequest> userRequest) {
         PlannerTemplateUpdateRequest req = userRequest.getRequestPayload();
         log.debug("PlannerTemplateUpdateRequest received");
+        if (plannerTemplateUpdateRequestValidation != null) {
+            IValidator validator = plannerTemplateUpdateRequestValidation.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process PlannerNewRequest id={}: {}", userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
         PlannerTemplate plannerTemplate = plannerTemplateMap.getSingleObjectByID(req.getId());
-        List<IRequestValidator.ValidationError> errors = plannerTemplateUpdateRequest.validate(req, imdgProvider);
-        if (IRequestValidator.checkErrorList(errors, log)) return;
         Instant updated = Instant.now();
         plannerTemplate.setUpdated(updated);
         plannerTemplate.setTask(req.getTask());
@@ -85,14 +121,26 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
         plannerTemplate.setSecurityId(req.getSecurityId());
         plannerTemplateMap.update(plannerTemplate);
         log.debug("successfully processed, new id {}", plannerTemplate.getId());
+        return null;
     }
 
-    private void deleteTimetable(BaseRequest<CommonDeleteRequest> userRequest) {
+    private RequestInfoUpdate deleteTimetable(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
         log.debug("CommonDeleteRequest received id = {}", req.getId());
-        List<IRequestValidator.ValidationError> errors = deleteRequestValidator.validate(req, imdgProvider);
+        if (plannerTemplateDeleteRequestValidation != null) {
-        if (IRequestValidator.checkErrorList(errors, log)) return;
+            IValidator validator = plannerTemplateDeleteRequestValidation.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process PlannerUpdateRequest id={}: {}", userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
         PlannerTemplate plannerTemplate = plannerTemplateMap.getSingleObjectByID(req.getId());
         plannerTemplateMap.delete(plannerTemplate);
+        return null;
     }
 }

clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/config/HazelcastServiceTestConfiguration.java

@@ -10,6 +10,8 @@ import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams;
 import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
 import ru.spcex.platform.imdg.iml.hazelcast.util.HazelcastHelper;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.enumeration.SimpleMessageResolver;
 
 import java.util.List;
 import java.util.Random;
@@ -65,4 +67,9 @@ public class HazelcastServiceTestConfiguration {
         params.setNearCacheConfig(new NearCacheConfig());
         return params;
     }
+
+    @Bean
+    public IMessageResolver messageResolver() {
+        return new SimpleMessageResolver();
+    }
 }

clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/service/PlannerTemplateServiceTest.java

@@ -26,6 +26,7 @@ import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateNewRequest;
 import ru.spcex.clearing.scheduler.service.PlannerTemplateService;
 import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.specx.clearing.scheduler.config.HazelcastServiceTestConfiguration;
 
 import java.time.Instant;
@@ -47,6 +48,7 @@ class PlannerTemplateServiceTest {
     private HazelcastService hazelcastServiceTest;
     private MockConsumer<String, Object> mockConsumer;
     private MockProducer<String, Object> mockProducer;
+    private IMessageResolver messageResolver;
 
     @BeforeEach
     void setUp() {
@@ -91,7 +93,7 @@ class PlannerTemplateServiceTest {
 
         //ACT
         //service set up
-        PlannerTemplateService plannerTemplateService = new PlannerTemplateService(mockConsumer, mockProducer, hazelcastServiceTest);
+        PlannerTemplateService plannerTemplateService = new PlannerTemplateService(mockConsumer, mockProducer, hazelcastServiceTest, messageResolver, null, null, null);
 
         //callbacks set up
         plannerTemplateService.afterPropertiesSet();