refactor, test fix

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

@@ -17,15 +17,12 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendar
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendarUpdateRequest;
 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.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.Optional;
 import java.util.function.Function;
 
 @Service
@@ -69,18 +66,8 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
     private RequestInfoUpdate newClearingCalendar(BaseRequest<ClearingCalendarNewRequest> userRequest) {
         ClearingCalendarNewRequest req = userRequest.getRequestPayload();
         log.debug("ClearingCalendarNewRequest received");
-        if (clearingCalendarNewRequestValidation != null) {
-            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);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, clearingCalendarNewRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         ClearingCalendar clearingCalendar = new ClearingCalendar();
         Instant created = Instant.now();
         clearingCalendar.setCreated(created);
@@ -95,18 +82,8 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
     private RequestInfoUpdate updateClearingCalendar(BaseRequest<ClearingCalendarUpdateRequest> userRequest) {
         ClearingCalendarUpdateRequest req = userRequest.getRequestPayload();
         log.debug("ClearingCalendarUpdateRequest received");
-        if (clearingCalendarUpdateRequestValidation != null) {
-            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);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, clearingCalendarUpdateRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         Instant updated = Instant.now();
         ClearingCalendar clearingCalendar = clearingCalendarMap.getSingleObjectByID(req.getId());
         clearingCalendar.setClearingDate(req.getClearingDate());
@@ -120,18 +97,8 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
 
     private RequestInfoUpdate deleteClearingCalendar(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
-        if (clearingCalendarDeleteRequestValidation != null) {
-            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);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, clearingCalendarDeleteRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         log.debug("CommonDeleteRequest received id = {}", req.getId());
         ClearingCalendar clearingCalendar = clearingCalendarMap.getSingleObjectByID(req.getId());
         clearingCalendarMap.delete(clearingCalendar);

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

@@ -17,15 +17,12 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerNewReques
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerUpdateRequest;
 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.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.Optional;
 import java.util.function.Function;
 
 @Service
@@ -70,18 +67,8 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
     private RequestInfoUpdate newScheduler(BaseRequest<PlannerNewRequest> userRequest) {
         PlannerNewRequest req = userRequest.getRequestPayload();
         log.debug("PlannerNewRequest received");
-        if (plannerNewRequestValidation != null) {
-            IValidator validator = plannerNewRequestValidation.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);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerNewRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         Planner planner = new Planner();
         planner.setCreated(Instant.now());
         planner.setTask(req.getTask());
@@ -99,18 +86,8 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
     private RequestInfoUpdate updateScheduler(BaseRequest<PlannerUpdateRequest> userRequest) {
         PlannerUpdateRequest req = userRequest.getRequestPayload();
         log.debug("PlannerUpdateRequest received id = {}", req.getId());
-        if (plannerUpdateRequestValidation != null) {
-            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);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerUpdateRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         Planner planner = plannerMap.getSingleObjectByID(req.getId());
         planner.setUpdated(Instant.now());
         planner.setTask(req.getTask());
@@ -127,18 +104,8 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
     private RequestInfoUpdate deleteScheduler(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
         log.debug("CommonDeleteRequest received id = {}", req.getId());
-        if (plannerDeleteRequestValidation != null) {
-            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);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerDeleteRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         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

@@ -17,15 +17,12 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateN
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateUpdateRequest;
 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.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.Optional;
 import java.util.function.Function;
 
 @Service
@@ -69,18 +66,8 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
     private RequestInfoUpdate newTimetable(BaseRequest<PlannerTemplateNewRequest> userRequest) {
         PlannerTemplateNewRequest req = userRequest.getRequestPayload();
         log.debug("PlannerTemplateNewRequest received");
-        if (plannerTemplateNewRequestValidation != null) {
-            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);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerTemplateNewRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         PlannerTemplate plannerTemplate = new PlannerTemplate();
         Instant created = Instant.now();
         plannerTemplate.setCreated(created);
@@ -97,18 +84,8 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
     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 PlannerTemplateNewRequest id={}: {}", userRequest.getId(), errorMsg);
-                return new RequestInfoUpdate()
-                        .setId(userRequest.getId())
-                        .setStatus(Status.Error)
-                        .setMessage(errorMsg);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerTemplateUpdateRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         PlannerTemplate plannerTemplate = plannerTemplateMap.getSingleObjectByID(req.getId());
         Instant updated = Instant.now();
         plannerTemplate.setUpdated(updated);
@@ -125,18 +102,8 @@ public class PlannerTemplateService extends QueueConsumer implements Initializin
     private RequestInfoUpdate deleteTimetable(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
         log.debug("CommonDeleteRequest received id = {}", req.getId());
-        if (plannerTemplateDeleteRequestValidation != null) {
-            IValidator validator = plannerTemplateDeleteRequestValidation.apply(req);
-            Optional<EnumMessage> validationError = validator.tillFirstError();
-            if (validationError.isPresent()) {
-                String errorMsg = messageResolver.resolve(validationError.get());
-                log.error("cannot process PlannerTemplateUpdateRequest id={}: {}", userRequest.getId(), errorMsg);
-                return new RequestInfoUpdate()
-                        .setId(userRequest.getId())
-                        .setStatus(Status.Error)
-                        .setMessage(errorMsg);
-            }
-        }
+        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerTemplateDeleteRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
         PlannerTemplate plannerTemplate = plannerTemplateMap.getSingleObjectByID(req.getId());
         plannerTemplateMap.delete(plannerTemplate);
         return null;

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

@@ -3,11 +3,13 @@ package ru.spcex.clearing.scheduler.validation.rules.common;
 import ru.clearing.platform.dictionary.AbstractDictionary;
 import ru.spcex.clearing.scheduler.error.ValidationError;
 import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 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.Collection;
 import java.util.Optional;
 import java.util.function.Function;
 
@@ -63,7 +65,11 @@ public record DictionaryPresentRule<R, D extends AbstractDictionary>(String fiel
                 dictionaryName,
                 dictionaryClass
         );
-        D dictionaryFromMap = dictImdg.getSingleObjectByFieldValues(Map.of("code", enumCode));
+        ImdgPredicateBuilder imdgPredicateBuilder = dictImdg.predicateBuilder();
+        ImdgPredicate imdgPredicate = imdgPredicateBuilder.equals("code", enumCode);
+        Collection<D> fromMap = dictImdg.getCollectionObjectsByPredicate(imdgPredicate);
+        assert fromMap.size() <= 1;
+        D dictionaryFromMap = fromMap.iterator().next();
         if (dictionaryFromMap == null) {
             return of(ValidationError.WrongDictionaryValue, fieldName);
         }

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

@@ -7,7 +7,6 @@ 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;
 
@@ -64,7 +63,7 @@ public record IdPresentRule<R, V extends SpcexObjectBase>(
         Long id = idGetter.apply(validatedObject);
         if (id == null) return required ? of(ValidationError.EmptyRequiredValue, fieldName) : empty();
         Imdg<V> imdg = context.obtainMap(mapName, mapClass);
-        V fromMap = imdg.getSingleObjectByFieldValues(Map.of("id", id));
+        V fromMap = imdg.getSingleObjectByID(id);
         if (fromMap == null) {
             return of(idNotPresentError, fieldName);
         }

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

@@ -17,25 +17,40 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.profile.Contact;
 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.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
+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.config.validation.ClearingCalendarValidationConfig;
+import ru.spcex.clearing.scheduler.config.validation.ValidationConfig;
 import ru.spcex.clearing.scheduler.service.ClearingCalendarService;
+import ru.spcex.platform.enumeration.DayStatus;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.validation.IValidator;
 import ru.specx.clearing.scheduler.config.HazelcastServiceTestConfiguration;
 
 import java.time.Instant;
 import java.time.LocalDate;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.function.Function;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
-        HazelcastServiceTestConfiguration.class})
+        HazelcastServiceTestConfiguration.class,
+        ValidationConfig.class,
+        ClearingCalendarValidationConfig.class
+})
 class ClearingCalendarServiceTest {
 
     private static final int PARTITION = 0;
@@ -48,6 +63,18 @@ class ClearingCalendarServiceTest {
     private MockConsumer<String, Object> mockConsumer;
     private MockProducer<String, Object> mockProducer;
 
+    @Autowired
+    private IMessageResolver messageResolver;
+
+    @Autowired
+    private Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidation;
+
+    @Autowired
+    private Function<ClearingCalendarNewRequest, IValidator> clearingCalendarNewRequestValidation;
+
+    @Autowired
+    private Function<ClearingCalendarUpdateRequest, IValidator> clearingCalendarUpdateRequestValidation;
+
     @BeforeEach
     void setUp() {
         mockConsumer = new MockConsumer<>(OffsetResetStrategy.EARLIEST);
@@ -61,8 +88,22 @@ class ClearingCalendarServiceTest {
      */
     @Test
     public void newClearingCalendarInQueue() throws InterruptedException {
-        //ARRANGE
+        // Prepare test objects
+        hazelcastServiceTest.waitAvailable();
+        Company company = new Company();
+        company.setId(0L);
+        company.setWorkflowStatus(WorkflowStatus.Active.getKey());
+        Imdg<Company> companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        companyImdg.insert(company);
 
+        DayStatus dayStatus = DayStatus.Workday;
+        DayStatusDictionary dayStatusDictionary = new DayStatusDictionary();
+        dayStatusDictionary.setId(0L);
+        dayStatusDictionary.setCode(dayStatus.getKey());
+        Imdg<DayStatusDictionary> dayStatusDictionaryImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_DayStatusDictionary, DayStatusDictionary.class);
+        dayStatusDictionaryImdg.insert(dayStatusDictionary);
+
+        //ARRANGE
         ClearingCalendar clearingCalendar = new ClearingCalendar();
         Instant created = Instant.now();
         clearingCalendar.setCreated(created);
@@ -89,10 +130,23 @@ class ClearingCalendarServiceTest {
 
         //ACT
         //service set up
-        ClearingCalendarService clearingCalendarService = new ClearingCalendarService(mockConsumer, mockProducer, hazelcastServiceTest);
+        ClearingCalendarService clearingCalendarService = new ClearingCalendarService(mockConsumer,
+                mockProducer,
+                hazelcastServiceTest,
+                messageResolver,
+                clearingCalendarDeleteRequestValidation,
+                clearingCalendarNewRequestValidation,
+                clearingCalendarUpdateRequestValidation);
 
         //callbacks set up
         clearingCalendarService.afterPropertiesSet();
+
+        BaseRequest<ClearingCalendarNewRequest> baseRequest = new BaseRequest<>();
+        baseRequest.setId(1L);
+        baseRequest.setActionType(ActionType.NEW);
+        ClearingCalendarNewRequest newRequest = new ClearingCalendarNewRequest();
+        baseRequest.setRequestPayload(newRequest);
+
         IMap<Long, ClearingCalendar> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_ClearingCalendar);
         //KAFKA
         HashMap<TopicPartition, Long> startOffsetsUpdating = new HashMap<>();

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

@@ -93,7 +93,13 @@ class PlannerTemplateServiceTest {
 
         //ACT
         //service set up
-        PlannerTemplateService plannerTemplateService = new PlannerTemplateService(mockConsumer, mockProducer, hazelcastServiceTest, messageResolver, null, null, null);
+        PlannerTemplateService plannerTemplateService = new PlannerTemplateService(mockConsumer,
+                mockProducer,
+                hazelcastServiceTest,
+                messageResolver,
+                null,
+                null,
+                null);
 
         //callbacks set up
         plannerTemplateService.afterPropertiesSet();

platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/service/QueueConsumer.java

@@ -16,16 +16,21 @@ import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.logic.functional.BuilderConsumerStep;
 import ru.spcex.clearing.platform.messaging.logic.functional.ConsumerSpecificClass;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.log.ExceptionUtils;
+import ru.spcex.platform.utils.validation.IValidator;
 
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Function;
 
 /**
  * утилитный класс для обработки сообщений из очереди
@@ -155,6 +160,31 @@ public class QueueConsumer implements AutoCloseable {
         return ConsumerSpecificClass.build(clazz);
     }
 
+
+    /**
+     * Валидация запроса
+     * @param <R> Класс проверяемого запроса
+     * @return null если ошибок нет
+     */
+    public <R> RequestInfoUpdate validate(BaseRequest<R> userRequest,
+                                             Function<R, IValidator> validatorBuilder,
+                                             IMessageResolver messageResolver) {
+        if (validatorBuilder != null) {
+            R req = userRequest.getRequestPayload();
+            IValidator validator = validatorBuilder.apply(req);
+            Optional<EnumMessage> validationError = validator.tillFirstError();
+            if (validationError.isPresent()) {
+                String errorMsg = messageResolver.resolve(validationError.get());
+                log.error("cannot process {} id={}: {}", req.getClass().getSimpleName(), userRequest.getId(), errorMsg);
+                return new RequestInfoUpdate()
+                        .setId(userRequest.getId())
+                        .setStatus(Status.Error)
+                        .setMessage(errorMsg);
+            }
+        }
+        return null;
+    }
+
     @Override
     public void close() {
         log.debug("Closing queue consumer {}", getClass().getSimpleName());