ClearingCalendarValidation

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

@@ -0,0 +1,100 @@
+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.ClearingCalendar;
+import ru.clearing.platform.dictionary.DayStatusDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendarNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendarUpdateRequest;
+import ru.spcex.clearing.scheduler.error.ValidationError;
+import ru.spcex.clearing.scheduler.validation.rules.common.DateNotBeforeRule;
+import ru.spcex.clearing.scheduler.validation.rules.common.DictionaryPresentRule;
+import ru.spcex.clearing.scheduler.validation.rules.common.IdPresentRule;
+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 ClearingCalendarValidationConfig {
+
+    @Bean("clearingCalendarNewRequestValidator")
+    public Function<ClearingCalendarNewRequest, IValidator> clearingCalendarNewRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return clearingCalendarNewRequest -> {
+            ImdgValidationContext<ClearingCalendarNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(clearingCalendarNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_DayStatusDictionary);
+            return new ValidatorImpl<>(context,
+                    DateNotBeforeRule.instance("clearingDate",
+                            ClearingCalendarNewRequest::getClearingDate),
+                    IdPresentRule.instance("companyId",
+                            ClearingCalendarNewRequest::getCompanyId,
+                            IMDGDistributedNames.Map_Company,
+                            Company.class,
+                            ValidationError.CompanyNotFound,
+                            company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
+                    DictionaryPresentRule.instance("dayStatus",
+                            ClearingCalendarNewRequest::getDayStatus,
+                            IMDGDistributedNames.Map_DayStatusDictionary,
+                            DayStatusDictionary.class)
+            );
+        };
+    }
+
+    @Bean("clearingCalendarUpdateRequestValidator")
+    public Function<ClearingCalendarUpdateRequest, IValidator> clearingCalendarUpdateRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return clearingCalendarUpdateRequest -> {
+            ImdgValidationContext<ClearingCalendarUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(clearingCalendarUpdateRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_DayStatusDictionary);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            ClearingCalendarUpdateRequest::getId,
+                            IMDGDistributedNames.Map_ClearingCalendar,
+                            ClearingCalendar.class,
+                            ValidationError.RecordNotFound),
+                    DateNotBeforeRule.instance("clearingDate",
+                            ClearingCalendarUpdateRequest::getClearingDate),
+                    IdPresentRule.instance("companyId",
+                            ClearingCalendarUpdateRequest::getCompanyId,
+                            IMDGDistributedNames.Map_Company,
+                            Company.class,
+                            ValidationError.CompanyNotFound,
+                            company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
+                    DictionaryPresentRule.instance("dayStatus",
+                            ClearingCalendarUpdateRequest::getDayStatus,
+                            IMDGDistributedNames.Map_DayStatusDictionary,
+                            DayStatusDictionary.class)
+            );
+        };
+    }
+
+    @Bean("clearingCalendarDeleteRequestValidator")
+    public Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidator() {
+        return clearingCalendarDeleteRequest -> {
+            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(clearingCalendarDeleteRequest);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            CommonDeleteRequest::getId,
+                            IMDGDistributedNames.Map_ClearingCalendar,
+                            ClearingCalendar.class,
+                            ValidationError.RecordNotFound)
+            );
+        };
+    }
+
+}

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

@@ -8,6 +8,7 @@ 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.platform.messaging.domain.cud.schedule.PlannerTemplateNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateUpdateRequest;
 import ru.spcex.clearing.scheduler.error.ValidationError;
@@ -80,7 +81,7 @@ public class PlannerTemplateValidationConfig {
                             PlannerTemplateUpdateRequest::getId,
                             IMDGDistributedNames.Map_PlannerTemplate,
                             PlannerTemplate.class,
-                            ValidationError.WrongUpdate),
+                            ValidationError.RecordNotFound),
                     DictionaryPresentRule.instance("task",
                             PlannerTemplateNewRequest::getTask,
                             IMDGDistributedNames.Map_TaskDictionary,
@@ -112,4 +113,20 @@ public class PlannerTemplateValidationConfig {
         };
     }
 
+
+    @Bean("plannerTemplateDeleteRequestValidator")
+    public Function<CommonDeleteRequest, IValidator> plannerTemplateDeleteRequestValidator() {
+        return plannerTemplateDeleteRequest -> {
+            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(plannerTemplateDeleteRequest);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            CommonDeleteRequest::getId,
+                            IMDGDistributedNames.Map_PlannerTemplate,
+                            PlannerTemplate.class,
+                            ValidationError.RecordNotFound)
+            );
+        };
+    }
+
 }

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

@@ -8,6 +8,7 @@ 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.platform.messaging.domain.cud.schedule.PlannerNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerUpdateRequest;
 import ru.spcex.clearing.scheduler.error.ValidationError;
@@ -85,7 +86,7 @@ public class PlannerValidationConfig {
                             PlannerUpdateRequest::getId,
                             IMDGDistributedNames.Map_Planner,
                             Planner.class,
-                            ValidationError.WrongUpdate),
+                            ValidationError.RecordNotFound),
                     DictionaryPresentRule.instance("task",
                             PlannerUpdateRequest::getTask,
                             IMDGDistributedNames.Map_TaskDictionary,
@@ -124,4 +125,19 @@ public class PlannerValidationConfig {
         };
     }
 
+    @Bean("plannerDeleteRequestValidator")
+    public Function<CommonDeleteRequest, IValidator> plannerDeleteRequestValidator() {
+        return plannerDeleteRequest -> {
+            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(plannerDeleteRequest);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            CommonDeleteRequest::getId,
+                            IMDGDistributedNames.Map_Planner,
+                            Planner.class,
+                            ValidationError.RecordNotFound)
+            );
+        };
+    }
+
 }

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

@@ -3,12 +3,15 @@ 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.ClearingCalendar;
 import ru.clearing.classes.statics.data.security.Security;
+import ru.clearing.platform.dictionary.DayStatusDictionary;
 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.clearing.scheduler.error.ValidationError;
+import ru.spcex.clearing.scheduler.validation.rules.common.IdPresentRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
@@ -32,16 +35,21 @@ public class ValidationConfig {
         addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class);
         addImdg.accept(IMDGDistributedNames.Map_Company, Company.class);
         addImdg.accept(IMDGDistributedNames.Map_Security, Security.class);
+        addImdg.accept(IMDGDistributedNames.Map_DayStatusDictionary, DayStatusDictionary.class);
         return imdg;
     }
 
     @Bean("commonDeleteRequestValidator")
-    public Function<CommonDeleteRequest, IValidator> commonDeleteRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+    public Function<CommonDeleteRequest, IValidator> commonDeleteRequestValidator() {
         return commonDeleteRequest -> {
             ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
             context.setValidatedObject(commonDeleteRequest);
             return new ValidatorImpl<>(context,
-                    FieldRequiredRule.instance("id", CommonDeleteRequest::getId)
+                    IdPresentRule.instance("id",
+                            CommonDeleteRequest::getId,
+                            IMDGDistributedNames.Map_ClearingCalendar,
+                            ClearingCalendar.class,
+                            ValidationError.RecordNotFound)
             );
         };
     }

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

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

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/ClearingCalendarService.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.ClearingCalendar;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
@@ -15,50 +16,71 @@ import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteReques
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendarNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendarUpdateRequest;
 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.stream.Collectors;
+import java.util.function.Function;
 
 @Service
 public class ClearingCalendarService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
-    private final ImdgProvider imdgProvider;
     private final Imdg<ClearingCalendar> clearingCalendarMap;
-    private final IRequestValidator<ClearingCalendarNewRequest> newRequestValidator = IRequestValidator.CLEARING_CALENDAR_NEW_REQUEST;
+    private final IMessageResolver messageResolver;
-    private final IRequestValidator<ClearingCalendarUpdateRequest> updateRequestValidator = IRequestValidator.CLEARING_CALENDAR_UPDATE_REQUEST;
+    private final Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidation;
-    private final IRequestValidator<CommonDeleteRequest> deleteRequestValidator = IRequestValidator.COMMON_DELETE_REQUEST;
+    private final Function<ClearingCalendarNewRequest, IValidator> clearingCalendarNewRequestValidation;
+    private final Function<ClearingCalendarUpdateRequest, IValidator> clearingCalendarUpdateRequestValidation;
 
     @Autowired
     public ClearingCalendarService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
-                                   ImdgProvider imdgProvider) {
+                                   ImdgProvider imdgProvider,
+                                   IMessageResolver messageResolver,
+                                   @Qualifier("clearingCalendarDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidator,
+                                   @Qualifier("clearingCalendarNewRequestValidator") Function<ClearingCalendarNewRequest, IValidator> clearingCalendarNewRequestValidator,
+                                   @Qualifier("clearingCalendarUpdateRequestValidator") Function<ClearingCalendarUpdateRequest, IValidator> clearingCalendarUpdateRequestValidator) {
         super(kafkaQueue, kafkaProducer);
         this.clearingCalendarMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingCalendar, ClearingCalendar.class);
-        this.imdgProvider = imdgProvider;
+        this.clearingCalendarDeleteRequestValidation = clearingCalendarDeleteRequestValidator;
+        this.clearingCalendarNewRequestValidation = clearingCalendarNewRequestValidator;
+        this.clearingCalendarUpdateRequestValidation = clearingCalendarUpdateRequestValidator;
+        this.messageResolver = messageResolver;
     }
 
     @Override
     public void afterPropertiesSet() {
         callback(ClearingCalendarNewRequest.class)
-                .setConsumer(this::newClearingCalendar)
+                .setFunction(this::newClearingCalendar)
                 .forDestination(Consts.DESTINATION_CLEARING_CALENDAR_NEW, callbacks::put);
         callback(ClearingCalendarUpdateRequest.class)
-                .setConsumer(this::updateClearingCalendar)
+                .setFunction(this::updateClearingCalendar)
                 .forDestination(Consts.DESTINATION_CLEARING_CALENDAR_UPDATE, callbacks::put);
         callback(CommonDeleteRequest.class)
-                .setConsumer(this::deleteClearingCalendar)
+                .setFunction(this::deleteClearingCalendar)
                 .forDestination(Consts.DESTINATION_CLEARING_CALENDAR_DELETE, callbacks::put);
         init();
     }
 
-    private void newClearingCalendar(BaseRequest<ClearingCalendarNewRequest> userRequest) {
+    private RequestInfoUpdate newClearingCalendar(BaseRequest<ClearingCalendarNewRequest> userRequest) {
         ClearingCalendarNewRequest req = userRequest.getRequestPayload();
         log.debug("ClearingCalendarNewRequest received");
-        List<IRequestValidator.ValidationError> errors = newRequestValidator.validate(req, imdgProvider);
+        if (clearingCalendarNewRequestValidation != null) {
-        if (IRequestValidator.checkErrorList(errors, log)) return;
+            IValidator validator = clearingCalendarNewRequestValidation.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process ClearingCalendarNewRequest id={}: {}", userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
         ClearingCalendar clearingCalendar = new ClearingCalendar();
         Instant created = Instant.now();
         clearingCalendar.setCreated(created);
@@ -67,13 +89,24 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
         clearingCalendar.setDayStatus(req.getDayStatus());
         clearingCalendarMap.insert(clearingCalendar);
         log.debug("successfully processed, new id {}", clearingCalendar.getId());
+        return null;
     }
 
-    private void updateClearingCalendar(BaseRequest<ClearingCalendarUpdateRequest> userRequest) {
+    private RequestInfoUpdate updateClearingCalendar(BaseRequest<ClearingCalendarUpdateRequest> userRequest) {
         ClearingCalendarUpdateRequest req = userRequest.getRequestPayload();
         log.debug("ClearingCalendarUpdateRequest received");
-        List<IRequestValidator.ValidationError> errors = updateRequestValidator.validate(req, imdgProvider);
+        if (clearingCalendarUpdateRequestValidation != null) {
-        if (IRequestValidator.checkErrorList(errors, log)) return;
+            IValidator validator = clearingCalendarUpdateRequestValidation.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process ClearingCalendarUpdateRequest id={}: {}", userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
         Instant updated = Instant.now();
         ClearingCalendar clearingCalendar = clearingCalendarMap.getSingleObjectByID(req.getId());
         clearingCalendar.setClearingDate(req.getClearingDate());
@@ -82,24 +115,26 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
         clearingCalendar.setUpdated(updated);
         clearingCalendarMap.update(clearingCalendar);
         log.debug("successfully processed, new id {}", clearingCalendar.getId());
+        return null;
     }
 
-    private void deleteClearingCalendar(BaseRequest<CommonDeleteRequest> userRequest) {
+    private RequestInfoUpdate deleteClearingCalendar(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
-        List<IRequestValidator.ValidationError> errors = deleteRequestValidator.validate(req, imdgProvider);
+        if (clearingCalendarDeleteRequestValidation != null) {
-        if (IRequestValidator.checkErrorList(errors, log)) return;
+            IValidator validator = clearingCalendarDeleteRequestValidation.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process CommonDeleteRequest id={}: {}", userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
         log.debug("CommonDeleteRequest received id = {}", req.getId());
         ClearingCalendar clearingCalendar = clearingCalendarMap.getSingleObjectByID(req.getId());
         clearingCalendarMap.delete(clearingCalendar);
-    }
+        return null;
-
-    static boolean checkErrors(List<IRequestValidator.ValidationError> errors, Logger log) {
-        if (!errors.isEmpty()) {
-            log.error("Validation error: [{}]",
-                    errors.stream().map(IRequestValidator.ValidationError::toString).collect(Collectors.joining(", "))
-            );
-            return true;
-        }
-        return false;
     }
 }

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

@@ -1,12 +0,0 @@
-package ru.spcex.clearing.scheduler.service;
-
-import ru.spcex.platform.utils.enumeration.EnumMessage;
-
-public class NewRequestResult {
-    private EnumMessage error;
-
-    public NewRequestResult(EnumMessage validationError) {
-        this.error = validationError;
-    }
-
-}

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

@@ -31,7 +31,6 @@ import java.util.function.Function;
 @Service
 public class PlannerService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
-    private final ImdgProvider imdgProvider;
     private final Imdg<Planner> plannerMap;
     private final IMessageResolver messageResolver;
     private final Function<CommonDeleteRequest, IValidator> plannerDeleteRequestValidation;
@@ -43,7 +42,7 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
                           Producer<String, Object> kafkaProducer,
                           ImdgProvider imdgProvider,
                           IMessageResolver messageResolver,
-                          @Qualifier("commonDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> plannerDeleteRequestValidator,
+                          @Qualifier("plannerDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> plannerDeleteRequestValidator,
                           @Qualifier("plannerNewRequestValidator") Function<PlannerNewRequest, IValidator> plannerNewRequestValidator,
                           @Qualifier("plannerUpdateRequestValidator") Function<PlannerUpdateRequest, IValidator> plannerUpdateRequestValidator) {
         super(kafkaQueue, kafkaProducer);
@@ -52,7 +51,6 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
         this.plannerDeleteRequestValidation = plannerDeleteRequestValidator;
         this.plannerNewRequestValidation = plannerNewRequestValidator;
         this.plannerUpdateRequestValidation = plannerUpdateRequestValidator;
-        this.imdgProvider = imdgProvider;
     }
 
     @Override

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

@@ -32,7 +32,6 @@ import java.util.function.Function;
 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 IMessageResolver messageResolver;
     private final Function<CommonDeleteRequest, IValidator> plannerTemplateDeleteRequestValidation;
     private final Function<PlannerTemplateNewRequest, IValidator> plannerTemplateNewRequestValidation;
@@ -42,12 +41,11 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
     public PlannerTemplateService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
                                   ImdgProvider imdgProvider,
                                   IMessageResolver messageResolver,
-                                  @Qualifier("commonDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> plannerTemplateDeleteRequestValidator,
+                                  @Qualifier("plannerTemplateDeleteRequestValidator") 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;
@@ -104,7 +102,7 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
             Optional<EnumMessage> validationError = validator.tillFirstError();
             if (validationError.isPresent()) {
                 String errorMsg = messageResolver.resolve(validationError.get());
-                log.error("cannot process PlannerNewRequest id={}: {}", userRequest.getId(), errorMsg);
+                log.error("cannot process PlannerTemplateNewRequest id={}: {}", userRequest.getId(), errorMsg);
                 return new RequestInfoUpdate()
                         .setId(userRequest.getId())
                         .setStatus(Status.Error)
@@ -132,7 +130,7 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
             Optional<EnumMessage> validationError = validator.tillFirstError();
             if (validationError.isPresent()) {
                 String errorMsg = messageResolver.resolve(validationError.get());
-                log.error("cannot process PlannerUpdateRequest id={}: {}", userRequest.getId(), errorMsg);
+                log.error("cannot process PlannerTemplateUpdateRequest id={}: {}", userRequest.getId(), errorMsg);
                 return new RequestInfoUpdate()
                         .setId(userRequest.getId())
                         .setStatus(Status.Error)

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

@@ -1,247 +0,0 @@
-package ru.spcex.clearing.scheduler.validation;
-
-import org.slf4j.Logger;
-import ru.clearing.platform.dictionary.AbstractDictionary;
-import ru.clearing.platform.dictionary.DayStatusDictionary;
-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.platform.messaging.domain.cud.schedule.*;
-import ru.spcex.platform.enumeration.Market;
-import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.utils.enumeration.IEnumKey;
-
-import java.time.LocalDate;
-import java.time.LocalTime;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public interface IRequestValidator<T> {
-    List<ValidationError> validate(T req, ImdgProvider imdgProvider);
-
-    /**
-     * Общий запрос на удаление
-     */
-    IRequestValidator<CommonDeleteRequest> COMMON_DELETE_REQUEST = (req, imdgProvider) -> {
-        var errors = new LinkedList<ValidationError>();
-        validateLong(req.id, "id", true, errors);
-        return errors;
-    };
-
-    /**
-     * Запрос на добавление ClearingCalendar
-     */
-    IRequestValidator<ClearingCalendarNewRequest> CLEARING_CALENDAR_NEW_REQUEST = (req, imdgProvider) -> {
-        var errors = new LinkedList<ValidationError>();
-        validateDate(req.clearingDate, "clearingDate", true, true, errors);
-        validateLong(req.companyId, "companyId", false, errors);
-//        validateEnum(req.dayStatus, "dayStatus", true, errors, DayStatus.values());
-        validateDictionary(req.dayStatus,
-                "dayStatus",
-                true,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_DayStatusDictionary, DayStatusDictionary.class),
-                errors);
-        return errors;
-    };
-
-    /**
-     * Запрос на обновление ClearingCalendar
-     */
-    IRequestValidator<ClearingCalendarUpdateRequest> CLEARING_CALENDAR_UPDATE_REQUEST = (req, imdgProvider) -> {
-        var errors = new LinkedList<ValidationError>();
-        validateLong(req.id, "id", true, errors);
-        validateLong(req.companyId, "companyId", false, errors);
-        validateDate(req.clearingDate, "clearingDate", false, true, errors);
-//        validateEnum(req.dayStatus, "dayStatus", false, errors, DayStatus.values());
-        validateDictionary(req.dayStatus,
-                "dayStatus",
-                false,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_DayStatusDictionary, DayStatusDictionary.class),
-                errors);
-        return errors;
-    };
-
-    /**
-     * Запрос на добавление Planner
-     */
-    IRequestValidator<PlannerNewRequest> PLANNER_NEW_REQUEST = (req, imdgProvider) -> {
-        var errors = new LinkedList<ValidationError>();
-//        validateEnum(req.task, "task", true, errors, Task.values());
-        validateDictionary(req.task,
-                "task",
-                true,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_TaskDictionary, TaskDictionary.class),
-                errors);
-        validateDate(req.clearingDate, "clearingDate", true, true, errors);
-        validateTime(req.taskTime, "taskTime", true, true, errors);
-        validateEnum(req.market, "market", false, errors, Market.values());
-//        validateEnum(req.taskStatus, "taskStatus", true, errors, Status.values());
-        validateDictionary(req.taskStatus,
-                "taskStatus",
-                true,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class),
-                errors);
-        validateLong(req.companyId, "companyId", false, errors);
-        validateLong(req.securityId, "securityId", false, errors);
-        return errors;
-    };
-
-    /**
-     * Запрос на обновление Planner
-     */
-    IRequestValidator<PlannerUpdateRequest> PLANNER_UPDATE_REQUEST = (req, imdgProvider) -> {
-        var errors = new LinkedList<ValidationError>();
-        validateLong(req.id, "id", true, errors);
-//        validateEnum(req.task, "task", false, errors, Task.values());
-        validateDictionary(req.task,
-                "task",
-                false,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_TaskDictionary, TaskDictionary.class),
-                errors);
-        validateDate(req.clearingDate, "clearingDate", false, true, errors);
-        validateTime(req.taskTime, "taskTime", false, true, errors);
-        validateEnum(req.market, "market", false, errors, Market.values());
-//        validateEnum(req.taskStatus, "taskStatus", false, errors, Status.values());
-        validateDictionary(req.taskStatus,
-                "taskStatus",
-                false,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class),
-                errors);
-        validateLong(req.companyId, "companyId", false, errors);
-        validateLong(req.securityId, "securityId", false, errors);
-        return errors;
-    };
-
-    /**
-     * Запрос на добавление PlannerTemplate
-     */
-    IRequestValidator<PlannerTemplateNewRequest> PLANNER_TEMPLATE_NEW_REQUEST = (req, imdgProvider) -> {
-        var errors = new LinkedList<ValidationError>();
-//        validateEnum(req.task, "task", true, errors, Task.values());
-        validateDictionary(req.task,
-                "task",
-                true,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_TaskDictionary, TaskDictionary.class),
-                errors);
-        validateTime(req.taskTime, "taskTime", true, true, errors);
-//        validateEnum(req.taskStatus, "taskStatus", true, errors, Status.values());
-        validateDictionary(req.taskStatus,
-                "taskStatus",
-                true,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class),
-                errors);
-        validateLong(req.companyId, "companyId", false, errors);
-        validateLong(req.securityId, "securityId", false, errors);
-        return errors;
-    };
-
-    /**
-     * Запрос на обновление PlannerTemplate
-     */
-    IRequestValidator<PlannerTemplateUpdateRequest> PLANNER_TEMPLATE_UPDATE_REQUEST = (req, imdgProvider) -> {
-        var errors = new LinkedList<ValidationError>();
-        validateLong(req.id, "id", true, errors);
-//        validateEnum(req.task, "task", false, errors, Task.values());
-        validateDictionary(req.task,
-                "task",
-                false,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_TaskDictionary, TaskDictionary.class),
-                errors);
-        validateTime(req.taskTime, "taskTime", false, true, errors);
-//        validateEnum(req.taskStatus, "taskStatus", false, errors, Status.values());
-        validateDictionary(req.taskStatus,
-                "taskStatus",
-                false,
-                imdgProvider.getImdg(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class),
-                errors);
-        validateLong(req.companyId, "companyId", false, errors);
-        validateLong(req.securityId, "securityId", false, errors);
-        return errors;
-    };
-
-
-
-    static <T extends AbstractDictionary> void validateDictionary(String src,
-                                   String fieldName,
-                                   boolean required,
-                                   Imdg<T> dictionary,
-                                   List<ValidationError> errors) {
-        if (src != null) {
-            boolean correctTask = false;
-            Collection<T> values = dictionary.getAllValues();
-            for (T value : values) correctTask |= src.equalsIgnoreCase(value.getCode());
-            if (!correctTask)
-                errors.add(new ValidationError(fieldName, ErrorType.UNKNOWN_VALUE));
-        } else if (required) errors.add(new ValidationError(fieldName, ErrorType.MISSING_REQUIRED));
-    }
-
-    static <T extends Enum<T> & IEnumKey> void validateEnum(String enumStr,
-                                                            String fieldName,
-                                                            boolean required,
-                                                            List<ValidationError> errors,
-                                                            T... enumSet) {
-        if (enumStr != null) {
-            boolean correctTask = IEnumKey.contains(enumStr, enumSet);
-            if (!correctTask)
-                errors.add(new ValidationError(fieldName, ErrorType.UNKNOWN_VALUE));
-        } else if (required) errors.add(new ValidationError(fieldName, ErrorType.MISSING_REQUIRED));
-    }
-
-    static void validateLong(Long value, String fieldName, boolean required, List<ValidationError> errors) {
-        if (value != null) {
-            if (value < 0 || value == Long.MAX_VALUE)
-                errors.add(new ValidationError(fieldName, ErrorType.INVALID_VALUE));
-        } else if (required) errors.add(new ValidationError(fieldName, ErrorType.MISSING_REQUIRED));
-    }
-
-    static void validateDate(LocalDate value,
-                             String fieldName,
-                             boolean required,
-                             boolean checkDate,
-                             List<ValidationError> errors) {
-        if (value != null) {
-            if (checkDate && (value.isBefore(LocalDate.now())))
-                errors.add(new ValidationError(fieldName, ErrorType.INVALID_VALUE));
-        } else if (required) errors.add(new ValidationError(fieldName, ErrorType.MISSING_REQUIRED));
-    }
-
-    static void validateTime(LocalTime value,
-                             String fieldName,
-                             boolean required,
-                             boolean checkDate,
-                             List<ValidationError> errors) {
-        if (value != null) {
-            if (checkDate && (value.isBefore(LocalTime.now())))
-                errors.add(new ValidationError(fieldName, ErrorType.INVALID_VALUE));
-        } else if (required) errors.add(new ValidationError(fieldName, ErrorType.MISSING_REQUIRED));
-    }
-
-    /**
-     * Временный метод
-     */
-    static boolean checkErrorList(List<IRequestValidator.ValidationError> errors, Logger log) {
-        if (!errors.isEmpty()) {
-            log.error("Validation idNotPresentError: [{}]",
-                    errors.stream().map(IRequestValidator.ValidationError::toString).collect(Collectors.joining(", "))
-            );
-            return true;
-        }
-        return false;
-    }
-
-    enum ErrorType {
-        MISSING_REQUIRED, UNKNOWN_VALUE, INVALID_VALUE
-    }
-
-    record ValidationError(String fieldName, ErrorType errorType) {
-        @Override
-        public String toString() {
-            return "%s: %s".formatted(fieldName, errorType);
-        }
-    }
-
-}