From 45e5c588b58b6f2909c2f65722588ed9a356c8d1 Mon Sep 17 00:00:00 2001 From: akulikov Date: Tue, 17 Jan 2023 16:59:07 +0300 Subject: [PATCH] PlannerTemplateServiceValidation --- .../SchedulerServiceApplication.java | 20 +-- .../scheduler/config/ValidationConfig.java | 85 ------------ .../PlannerTemplateValidationConfig.java | 115 ++++++++++++++++ .../validation/PlannerValidationConfig.java | 127 ++++++++++++++++++ .../config/validation/ValidationConfig.java | 49 +++++++ .../scheduler/error/ValidationError.java | 1 + .../scheduler/service/PlannerService.java | 76 +++++++---- .../service/PlannerTemplateService.java | 84 +++++++++--- .../HazelcastServiceTestConfiguration.java | 7 + .../service/PlannerTemplateServiceTest.java | 4 +- 10 files changed, 420 insertions(+), 148 deletions(-) delete mode 100644 clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/ValidationConfig.java create mode 100644 clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerTemplateValidationConfig.java create mode 100644 clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerValidationConfig.java create mode 100644 clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/ValidationConfig.java diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/SchedulerServiceApplication.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/SchedulerServiceApplication.java index 8558b06f8..6022af291 100644 --- a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/SchedulerServiceApplication.java +++ b/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); - PlannerService plannerService = context.getBean(PlannerService.class); - try { - Thread.sleep(100000); - } catch (InterruptedException e) { - e.printStackTrace(); - } - var baseRequest = new BaseRequest(); - var plannerNewRequest = new PlannerNewRequest(); - plannerNewRequest.task = "GBAL"; - baseRequest.setId(777L); - baseRequest.setRequestPayload(plannerNewRequest); - RequestInfoUpdate requestInfoUpdate = plannerService.newScheduler(baseRequest); - System.out.println(requestInfoUpdate.toString()); + springApplication.run(args); } } diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/ValidationConfig.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/ValidationConfig.java deleted file mode 100644 index 28bf7a2c4..000000000 --- a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/ValidationConfig.java +++ /dev/null @@ -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> imdgs; - - public ValidationConfig(ImdgProvider imdgProvider) { - this.imdgs = new HashMap<>(); - BiConsumer> 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 plannerNewRequestValidator() { - return plannerNewRequest -> { - ImdgValidationContext context = new ImdgValidationContext<>(); - context.setValidatedObject(plannerNewRequest); - Consumer 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) - ); - }; - } - -} diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerTemplateValidationConfig.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerTemplateValidationConfig.java new file mode 100644 index 000000000..efb0b64ad --- /dev/null +++ b/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 plannerNewRequestValidator(Map> imdgForValidation) { + return plannerNewRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(plannerNewRequest); + Consumer 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 plannerUpdateRequestValidator(Map> imdgForValidation) { + return plannerUpdateRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(plannerUpdateRequest); + Consumer 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) + ); + }; + } + +} diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerValidationConfig.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerValidationConfig.java new file mode 100644 index 000000000..7c8963650 --- /dev/null +++ b/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 plannerNewRequestValidator(Map> imdgForValidation) { + return plannerNewRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(plannerNewRequest); + Consumer 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 plannerUpdateRequestValidator(Map> imdgForValidation) { + return plannerUpdateRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(plannerUpdateRequest); + Consumer 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) + ); + }; + } + +} diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/ValidationConfig.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/ValidationConfig.java new file mode 100644 index 000000000..e4b471c69 --- /dev/null +++ b/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> imdgForValidation(ImdgProvider imdgProvider) { + final Map> imdg = new HashMap<>(); + BiConsumer> 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 commonDeleteRequestValidator(Map> imdgForValidation) { + return commonDeleteRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(commonDeleteRequest); + return new ValidatorImpl<>(context, + FieldRequiredRule.instance("id", CommonDeleteRequest::getId) + ); + }; + } + +} diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/error/ValidationError.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/error/ValidationError.java index bdc24ed06..861e85337 100644 --- a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/error/ValidationError.java +++ b/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), diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/PlannerService.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/PlannerService.java index 4a069ec79..b61905894 100644 --- a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/PlannerService.java +++ b/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 plannerMap; private final IMessageResolver messageResolver; - private final Function validationFactory; - private final IRequestValidator plannerUpdateRequest = IRequestValidator.PLANNER_UPDATE_REQUEST; - private final IRequestValidator deleteRequestValidator = IRequestValidator.COMMON_DELETE_REQUEST; + private final Function plannerDeleteRequestValidation; + private final Function plannerNewRequestValidation; + private final Function plannerUpdateRequestValidation; @Autowired public PlannerService(Consumer kafkaQueue, Producer kafkaProducer, ImdgProvider imdgProvider, IMessageResolver messageResolver, - @Qualifier("plannerNewRequestValidator") Function plannerNewRequestValidator) { + @Qualifier("commonDeleteRequestValidator") Function plannerDeleteRequestValidator, + @Qualifier("plannerNewRequestValidator") Function plannerNewRequestValidator, + @Qualifier("plannerUpdateRequestValidator") Function 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 userRequest) { + private RequestInfoUpdate newScheduler(BaseRequest userRequest) { PlannerNewRequest req = userRequest.getRequestPayload(); log.debug("PlannerNewRequest received"); - IValidator validator = validationFactory.apply(req); - Optional 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); + if (plannerNewRequestValidation != null) { + IValidator validator = plannerNewRequestValidation.apply(req); + Optional 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); + } } 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 userRequest) { + private RequestInfoUpdate updateScheduler(BaseRequest userRequest) { PlannerUpdateRequest req = userRequest.getRequestPayload(); log.debug("PlannerUpdateRequest received id = {}", req.getId()); - List errors = plannerUpdateRequest.validate(req, imdgProvider); - if (IRequestValidator.checkErrorList(errors, log)) return; + if (plannerUpdateRequestValidation != null) { + IValidator validator = plannerUpdateRequestValidation.apply(req); + Optional 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 userRequest) { + private RequestInfoUpdate deleteScheduler(BaseRequest userRequest) { CommonDeleteRequest req = userRequest.getRequestPayload(); log.debug("CommonDeleteRequest received id = {}", req.getId()); - List errors = deleteRequestValidator.validate(req, imdgProvider); - if (IRequestValidator.checkErrorList(errors, log)) return; + if (plannerDeleteRequestValidation != null) { + IValidator validator = plannerDeleteRequestValidation.apply(req); + Optional 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; } } diff --git a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/PlannerTemplateService.java b/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/PlannerTemplateService.java index 6cf914e9b..63fc0cfce 100644 --- a/clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/PlannerTemplateService.java +++ b/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 plannerTemplateMap; private final ImdgProvider imdgProvider; - private final IRequestValidator plannerTemplateNewRequest = IRequestValidator.PLANNER_TEMPLATE_NEW_REQUEST; - private final IRequestValidator plannerTemplateUpdateRequest = IRequestValidator.PLANNER_TEMPLATE_UPDATE_REQUEST; - private final IRequestValidator deleteRequestValidator = IRequestValidator.COMMON_DELETE_REQUEST; + private final IMessageResolver messageResolver; + private final Function plannerTemplateDeleteRequestValidation; + private final Function plannerTemplateNewRequestValidation; + private final Function plannerTemplateUpdateRequestValidation; @Autowired public PlannerTemplateService(Consumer kafkaQueue, Producer kafkaProducer, - ImdgProvider imdgProvider) { + ImdgProvider imdgProvider, + IMessageResolver messageResolver, + @Qualifier("commonDeleteRequestValidator") Function plannerTemplateDeleteRequestValidator, + @Qualifier("plannerTemplateNewRequestValidator") Function plannerTemplateNewRequestValidator, + @Qualifier("plannerTemplateUpdateRequestValidator") Function 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 userRequest) { + private RequestInfoUpdate newTimetable(BaseRequest userRequest) { PlannerTemplateNewRequest req = userRequest.getRequestPayload(); log.debug("PlannerTemplateNewRequest received"); - List errors = plannerTemplateNewRequest.validate(req, imdgProvider); - if (IRequestValidator.checkErrorList(errors, log)) return; + if (plannerTemplateNewRequestValidation != null) { + IValidator validator = plannerTemplateNewRequestValidation.apply(req); + Optional 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 userRequest) { + private RequestInfoUpdate updateTimetable(BaseRequest userRequest) { PlannerTemplateUpdateRequest req = userRequest.getRequestPayload(); log.debug("PlannerTemplateUpdateRequest received"); + if (plannerTemplateUpdateRequestValidation != null) { + IValidator validator = plannerTemplateUpdateRequestValidation.apply(req); + Optional 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 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 userRequest) { + private RequestInfoUpdate deleteTimetable(BaseRequest userRequest) { CommonDeleteRequest req = userRequest.getRequestPayload(); log.debug("CommonDeleteRequest received id = {}", req.getId()); - List errors = deleteRequestValidator.validate(req, imdgProvider); - if (IRequestValidator.checkErrorList(errors, log)) return; + if (plannerTemplateDeleteRequestValidation != null) { + IValidator validator = plannerTemplateDeleteRequestValidation.apply(req); + Optional 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; } } diff --git a/clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/config/HazelcastServiceTestConfiguration.java b/clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/config/HazelcastServiceTestConfiguration.java index af55150d0..48b9644d4 100644 --- a/clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/config/HazelcastServiceTestConfiguration.java +++ b/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(); + } } diff --git a/clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/service/PlannerTemplateServiceTest.java b/clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/service/PlannerTemplateServiceTest.java index ff5ac8109..c9bac35d7 100644 --- a/clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/service/PlannerTemplateServiceTest.java +++ b/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 mockConsumer; private MockProducer 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();