treshenkov/clearing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ClearingCalendarValidation

Browse source
This commit is contained in:
akulikov 2023-01-17 17:54:08 +03:00
parent 45e5c588b5
commit ff8dd10f52
10 changed files with 217 additions and 304 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/ClearingCalendarValidationConfig.java Normal file
View file

@ -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)
);
};
}
}

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

@ -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)
);
};
}
}

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

@ -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)
);
};
}
}

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

@ -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)
);
};
}

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

@ -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),

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

@ -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.stream.Collectors;
import java.util.Optional;
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 IRequestValidator<ClearingCalendarUpdateRequest> updateRequestValidator = IRequestValidator.CLEARING_CALENDAR_UPDATE_REQUEST;
private final IRequestValidator<CommonDeleteRequest> deleteRequestValidator = IRequestValidator.COMMON_DELETE_REQUEST;
private final IMessageResolver messageResolver;
private final Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidation;
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 (IRequestValidator.checkErrorList(errors, log)) return;
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);
}
}
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 (IRequestValidator.checkErrorList(errors, log)) return;
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);
}
}
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 (IRequestValidator.checkErrorList(errors, log)) return;
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);
}
}
log.debug("CommonDeleteRequest received id = {}", req.getId());
ClearingCalendar clearingCalendar = clearingCalendarMap.getSingleObjectByID(req.getId());
clearingCalendarMap.delete(clearingCalendar);
}
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;
return null;
}
}

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

@ -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;
}
}

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

@ -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

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

@ -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)

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

@ -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);
}
}
}