diff --git a/clearing-parent/utility-service/pom.xml b/clearing-parent/utility-service/pom.xml index c74167c72..74362e76a 100644 --- a/clearing-parent/utility-service/pom.xml +++ b/clearing-parent/utility-service/pom.xml @@ -32,6 +32,14 @@ ru.spcex.clearing classes + + ru.spcex.clearing + clearing-validation + + + ru.spcex.clearing + security-util + org.springframework.boot spring-boot-starter diff --git a/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/Enum/UtilityError.java b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/Enum/UtilityError.java new file mode 100644 index 000000000..a1fe5d19b --- /dev/null +++ b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/Enum/UtilityError.java @@ -0,0 +1,23 @@ +package ru.spcex.clearing.utility.Enum; + +import ru.spcex.platform.utils.enumeration.IErrorEnumId; + +public enum UtilityError implements IErrorEnumId { + GeneralError(2000L), + UserVerifyDenial(2001L), + RequiredFieldEmpty(2002L), + RecordAlreadyExist(2005L), + RecordNotFound(2006L), + ; + + private final Long id; + + UtilityError(Long id) { + this.id = id; + } + + @Override + public Long getId() { + return id; + } +} diff --git a/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/config/validation/ValidateSymbolsValidationConfig.java b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/config/validation/ValidateSymbolsValidationConfig.java new file mode 100644 index 000000000..bf2721fdf --- /dev/null +++ b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/config/validation/ValidateSymbolsValidationConfig.java @@ -0,0 +1,146 @@ +package ru.spcex.clearing.utility.config.validation; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import ru.clearing.classes.statics.data.misc.ValidationSymbols; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.misc.ValidationSymbolsNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.misc.ValidationSymbolsUpdateRequest; +import ru.spcex.clearing.utility.Enum.UtilityError; +import ru.spcex.clearing.validation.common.rules.FieldRequiredRule; +import ru.spcex.clearing.validation.common.rules.IdPresentRule; +import ru.spcex.platform.classes.base.SpcexObjectBase; +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 ru.spcex.platform.utils.validation.IValidator; +import ru.spcex.platform.utils.validation.ValidatorImpl; + +import java.util.Collection; +import java.util.Map; +import java.util.Optional; +import java.util.function.Consumer; +import java.util.function.Function; + +@Configuration +public class ValidateSymbolsValidationConfig { + + @Bean("validationSymbolsNewRequestRequestValidator") + public Function validateSymbolsNewRequestValidator( + Map> imdgForValidation + ) { + return validationSymbolsNewRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(validationSymbolsNewRequest); + Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_ValidationSymbols); + + return new ValidatorImpl<>(context, + FieldRequiredRule.instance("code", + ValidationSymbolsNewRequest::getCode, + UtilityError.RequiredFieldEmpty), + FieldRequiredRule.instance("symbols", + ValidationSymbolsNewRequest::getSymbols, + UtilityError.RequiredFieldEmpty), + new newVSDuplicateCheck() + ); + }; + } + + static class newVSDuplicateCheck implements IValidationRule> { + @Override + public Optional validate(ImdgValidationContext context) { + ValidationSymbolsNewRequest validatedObject = context.getValidatedObject(); + Imdg tcrMap = context.obtainMap(IMDGDistributedNames.Map_ValidationSymbols, ValidationSymbols.class); + + if (validatedObject.getCode() == null) { + return empty(); + } + ImdgPredicateBuilder pb = tcrMap.predicateBuilder(); + ImdgPredicate query = pb.equals("code", validatedObject.getCode()); + + Collection existVS = tcrMap.getCollectionObjectsByPredicate(query); + + if (existVS.isEmpty()) { + return empty(); + } else { + return of(UtilityError.RecordAlreadyExist, validatedObject.getCode()); + } + } + } + + static class updateVSDuplicateCheck implements IValidationRule> { + @Override + public Optional validate(ImdgValidationContext context) { + ValidationSymbolsUpdateRequest validatedObject = context.getValidatedObject(); + Imdg tcrMap = context.obtainMap(IMDGDistributedNames.Map_ValidationSymbols, ValidationSymbols.class); + + if (validatedObject.getCode() == null) { + return empty(); + } + ImdgPredicateBuilder pb = tcrMap.predicateBuilder(); + ImdgPredicate query = pb.and(pb.equals("code", validatedObject.getCode()), + pb.not(pb.equals("id", validatedObject.getId()))); + + Collection existVS = tcrMap.getCollectionObjectsByPredicate(query); + + if (existVS.isEmpty()) { + return empty(); + } else { + return of(UtilityError.RecordAlreadyExist, validatedObject.getCode()); + } + } + } + + + @Bean("validationSymbolsUpdateRequestRequestValidator") + public Function validationSymbolsUpdateRequestValidator( + Map> imdgForValidation + ) { + return validationSymbolsUpdateRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(validationSymbolsUpdateRequest); + Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_ValidationSymbols); + return new ValidatorImpl<>(context, + IdPresentRule.instance("id", + ValidationSymbolsUpdateRequest::getId, + IMDGDistributedNames.Map_ValidationSymbols, + ValidationSymbols.class, + UtilityError.RequiredFieldEmpty, + UtilityError.RecordNotFound), + FieldRequiredRule.instance("code", + ValidationSymbolsNewRequest::getCode, + UtilityError.RequiredFieldEmpty), + FieldRequiredRule.instance("symbols", + ValidationSymbolsNewRequest::getSymbols, + UtilityError.RequiredFieldEmpty), + new updateVSDuplicateCheck() + ); + }; + } + + @Bean("validationSymbolsDeleteRequestRequestValidator") + public Function validationSymbolsDeleteRequestValidator( + Map> imdgForValidation + ) { + return validateSymbolsDeleteRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(validateSymbolsDeleteRequest); + Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_ValidationSymbols); + return new ValidatorImpl<>(context, + IdPresentRule.instance("id", + CommonIdRequest::getId, + IMDGDistributedNames.Map_ValidationSymbols, + ValidationSymbols.class, + UtilityError.RequiredFieldEmpty, + UtilityError.RecordNotFound) + ); + }; + } +} diff --git a/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/config/validation/ValidationConfig.java b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/config/validation/ValidationConfig.java new file mode 100644 index 000000000..0a93dfc00 --- /dev/null +++ b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/config/validation/ValidationConfig.java @@ -0,0 +1,55 @@ +package ru.spcex.clearing.utility.config.validation; + + +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Scope; +import ru.clearing.classes.statics.data.misc.ValidationSymbols; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.util.security.UserRoleVerification; +import ru.spcex.clearing.util.services.IMDGMessageResolver; +import ru.spcex.clearing.utility.Enum.UtilityError; +import ru.spcex.clearing.validation.common.ValidationHelper; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.enumeration.UserRole; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.utils.enumeration.IMessageResolver; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.BiConsumer; + +@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_ValidationSymbols, ValidationSymbols.class); + + return imdg; + } + + @Bean("validationHelper") + public ValidationHelper validationHelper(IMessageResolver messageResolver) { + return new ValidationHelper(messageResolver); + } + + + @Bean + public IMessageResolver messageResolver(ImdgProvider imdgProvider) { + return new IMDGMessageResolver(imdgProvider); + } + + + @Bean + @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public UserRoleVerification userRoleVerification(ImdgProvider imdgProvider, IMessageResolver messageResolver) { + return new UserRoleVerification(imdgProvider, messageResolver, UserRole.Admin, UtilityError.UserVerifyDenial); + } +} + diff --git a/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/ValidationSymbolsService.java b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/ValidationSymbolsService.java new file mode 100644 index 000000000..c1ddf9c74 --- /dev/null +++ b/clearing-parent/utility-service/src/main/java/ru/spcex/clearing/utility/service/ValidationSymbolsService.java @@ -0,0 +1,164 @@ +package ru.spcex.clearing.utility.service; + +import org.apache.kafka.clients.consumer.Consumer; +import org.apache.kafka.clients.producer.Producer; +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.account.ClientCode; +import ru.clearing.classes.statics.data.misc.ValidationSymbols; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.BaseRequest; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.misc.ValidationSymbolsNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.misc.ValidationSymbolsUpdateRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.utilities.NotificationNewRequest; +import ru.spcex.clearing.platform.messaging.serialization.LogFormatter; +import ru.spcex.clearing.platform.messaging.service.QueueConsumer; +import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; +import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender; +import ru.spcex.clearing.util.security.UserRoleVerification; +import ru.spcex.clearing.validation.common.ValidationHelper; +import ru.spcex.platform.enumeration.*; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder; +import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast; +import ru.spcex.platform.utils.collection.Pair; +import ru.spcex.platform.utils.number.BigDecimalUtil; +import ru.spcex.platform.utils.validation.IValidator; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; + +@Service +public class ValidationSymbolsService extends QueueConsumer implements InitializingBean { + private final Logger log = LoggerFactory.getLogger(getClass()); + + private final Imdg validationSymbolsImdg; + private final ImdgProvider imdgProvider; + private final KafkaSender kafkaSender; + + private final ValidationHelper validationHelper; + private final UserRoleVerification userRoleVerification; + final Function validationSymbolsNewRequestValidator; + final Function validationSymbolsUpdateRequestValidator; + final Function validationSymbolsDeleteRequestValidator; + + + @Autowired + public ValidationSymbolsService(ImdgProvider imdgProvider, + UserRoleVerification userRoleVerification, + ValidationHelper validationHelper, + + @Qualifier("validationSymbolsNewRequestRequestValidator") + Function validationSymbolsNewRequestValidator, + @Qualifier("validationSymbolsUpdateRequestRequestValidator") + Function validationSymbolsUpdateRequestValidator, + @Qualifier("validationSymbolsDeleteRequestRequestValidator") + Function validationSymbolsDeleteRequestValidator, + + KafkaSender kafkaSender, + Producer kafkaProducer, + Consumer kafkaQueue) { + super(kafkaQueue, kafkaProducer); + this.imdgProvider = imdgProvider; + this.kafkaSender = kafkaSender; + this.validationSymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ValidationSymbols, ValidationSymbols.class); + + this.userRoleVerification = userRoleVerification; + this.validationHelper = validationHelper; + this.validationSymbolsNewRequestValidator = validationSymbolsNewRequestValidator; + this.validationSymbolsUpdateRequestValidator = validationSymbolsUpdateRequestValidator; + this.validationSymbolsDeleteRequestValidator = validationSymbolsDeleteRequestValidator; + } + + @Override + public void afterPropertiesSet() throws Exception { + callback(ValidationSymbolsNewRequest.class) + .setFunction(this::onValidateSymbolNewRequest) + .forDestination(Consts.DESTINATION_VALIDATE_SYMBOLS_NEW, callbacks::put); + callback(ValidationSymbolsUpdateRequest.class) + .setFunction(this::onValidateSymbolUpdateRequest) + .forDestination(Consts.DESTINATION_VALIDATE_SYMBOLS_UPDATE, callbacks::put); + callback(CommonIdRequest.class) + .setFunction(this::onValidateSymbolDeleteRequest) + .forDestination(Consts.DESTINATION_VALIDATE_SYMBOLS_DELETE, callbacks::put); + init(); + } + + public RequestInfoUpdate onValidateSymbolNewRequest(BaseRequest userRequest) { + log.debug("ValidationSymbolsNewRequest received {}", userRequest.getId()); + + RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); + if (requestInfoUpdate != null) return requestInfoUpdate; + + requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validationSymbolsNewRequestValidator); + if (requestInfoUpdate != null) return requestInfoUpdate; + + ValidationSymbolsNewRequest req = userRequest.getRequestPayload(); + + ValidationSymbols vs = new ValidationSymbols(); + vs.setId(validationSymbolsImdg.nextIDSequenceFor()); + vs.setCode(req.getCode()); + vs.setSymbols(req.getSymbols()); + vs.setComment(req.getComment()); + validationSymbolsImdg.insert(vs); + log.info("New ValidationSymbols.id={} was created.", vs.getId()); + return null; + //return requestHelper.success(vs.getId()); // new RequestInfoUpdate(id, Status.Success, null) + } + + public RequestInfoUpdate onValidateSymbolUpdateRequest(BaseRequest userRequest) { + log.debug("ValidationSymbolsUpdateRequest received {}", userRequest.getId()); + + RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); + if (requestInfoUpdate != null) return requestInfoUpdate; + + requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validationSymbolsUpdateRequestValidator); + if (requestInfoUpdate != null) return requestInfoUpdate; + + ValidationSymbolsUpdateRequest req = userRequest.getRequestPayload(); + ValidationSymbols vs = validationSymbolsImdg.getSingleObjectByID(req.getId()); + vs.setCode(req.getCode()); + vs.setSymbols(req.getSymbols()); + vs.setComment(req.getComment()); + validationSymbolsImdg.update(vs); + log.info("Update ValidationSymbols.id={} was created.", vs.getId()); + return null; + //return requestHelper.success(vs.getId()); // new RequestInfoUpdate(id, Status.Success, null) + } + + public RequestInfoUpdate onValidateSymbolDeleteRequest(BaseRequest userRequest) { + log.debug("ValidationSymbolsDeleteRequest received {}", userRequest.getId()); + + RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); + if (requestInfoUpdate != null) return requestInfoUpdate; + + requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validationSymbolsDeleteRequestValidator); + if (requestInfoUpdate != null) return requestInfoUpdate; + + CommonIdRequest req = userRequest.getRequestPayload(); + ValidationSymbols vs = validationSymbolsImdg.getSingleObjectByID(req.getId()); + validationSymbolsImdg.delete(vs); + log.info("Delete ValidationSymbols.id={} was created.", vs.getId()); + return null; + } + +} diff --git a/clearing-parent/utility-service/src/test/java/ru/spcex/clearing/utility/service/ValidationSymbolsServiceTest.java b/clearing-parent/utility-service/src/test/java/ru/spcex/clearing/utility/service/ValidationSymbolsServiceTest.java new file mode 100644 index 000000000..021790341 --- /dev/null +++ b/clearing-parent/utility-service/src/test/java/ru/spcex/clearing/utility/service/ValidationSymbolsServiceTest.java @@ -0,0 +1,170 @@ +package ru.spcex.clearing.utility.service; + +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +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.misc.ValidationSymbols; +import ru.clearing.classes.statics.data.register.PairSdf; +import ru.clearing.classes.statics.data.sdf.SDf01; +import ru.clearing.classes.statics.data.sdf.SDf02; +import ru.clearing.classes.statics.data.security.DigitalCertificateSecurity; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.misc.ValidationSymbolsNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.misc.ValidationSymbolsUpdateRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.utilities.PairSdfRequest; +import ru.spcex.clearing.test.MatcherFactory; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.clearing.utility.config.TestConfig; +import ru.spcex.clearing.utility.config.settings.UtilityServiceSettings; +import ru.spcex.clearing.utility.config.validation.ValidateSymbolsValidationConfig; +import ru.spcex.clearing.utility.config.validation.ValidationConfig; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +import javax.annotation.PostConstruct; +import java.io.File; +import java.nio.file.Path; +import java.nio.file.Paths; + +import static org.junit.jupiter.api.Assertions.*; +import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator; +import static ru.spcex.clearing.test.TestUtils.*; +import static ru.spcex.clearing.test.TestUtils.waitingSendAndCheckRecord; +import static ru.spcex.clearing.test.config.ImdgTestConfig.currentID; +import static ru.spcex.clearing.test.config.ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + +// UtilityServiceSettings.class, + TestConfig.class, + ImdgTestConfig.class, + KafkaTestConfig.class, + + ValidationConfig.class, + ValidateSymbolsValidationConfig.class, + ValidationSymbolsService.class +}) +class ValidationSymbolsServiceTest { + private static final MatcherFactory.Matcher VS_MATCHER = usingIgnoringFieldsComparator(); + +// private static final Long inGenerationId = currentID.getAndIncrement(); +// private static final Long outGenerationId = currentID.getAndIncrement(); +// private static final Long inSdfId = currentID.getAndIncrement(); + + @Autowired + private ValidationSymbolsService validationSymbolsService; + + @Autowired + @Qualifier("hazelcastServiceTest") + protected ImdgProvider imdgProvider; + + @Autowired + @Qualifier("mockProducer") + protected Producer mockProducer; + + private Imdg validationSymbolsIMDG; + + static { + Path path = Paths.get("src", "main", "resources"); + String currentPath = path.toAbsolutePath().toString(); + System.setProperty("spring.config.location", currentPath + File.separator); + } + + @PostConstruct + public void init(){ + waitAvailableImdgProviderAndAddAdminWithDefaultId(); + this.validationSymbolsIMDG = imdgProvider.getImdg(IMDGDistributedNames.Map_ValidationSymbols, ValidationSymbols.class); +// SDf02 sDf02 = new SDf02(); +// sDf02.setGenerationId(outGenerationId); +// sDf02.setInSDfId(inSdfId); +// sDf02Imdg.insert(sDf02); + } + + @Test + void onValidateSymbolNewRequest() { + Long ID = currentID.getAndIncrement(); + + ValidationSymbolsNewRequest newReq = new ValidationSymbolsNewRequest(); + newReq.setCode("Alphabet Az"); + newReq.setSymbols("A-z"); + newReq.setComment("Testing aZ"); + + String jsonString = getJsonStringForNew(newReq, ID); + addRecordToKafka((MockConsumer) validationSymbolsService.getConsumer(), Consts.DESTINATION_VALIDATE_SYMBOLS_NEW, 0, 0, jsonString); + waitingSendAndCheckRecord(ID, mockProducer); + + + ValidationSymbols newValidateSymbols = validationSymbolsIMDG.getFirstObjectBySQL( + String.format("comment = %s", newReq.getComment()) + ); + ValidationSymbols vsPrediction=new ValidationSymbols(); + vsPrediction.setId(newValidateSymbols.getId()); + vsPrediction.setCode("Alphabet Az"); + vsPrediction.setSymbols("A-z"); + vsPrediction.setComment("Testing aZ"); + VS_MATCHER.assertMatch(newValidateSymbols, vsPrediction); + } + + @Test + void onValidateSymbolUpdateRequest() { + Long ID = currentID.getAndIncrement(); + ValidationSymbols vsOld = new ValidationSymbols(); + vsOld.setId(ID); + vsOld.setCode("Alphabet Az"); + vsOld.setSymbols("A-F"); + vsOld.setComment("Testing aZ"); + validationSymbolsIMDG.insert(vsOld); + + + ValidationSymbolsUpdateRequest newReq = new ValidationSymbolsUpdateRequest(); + newReq.setId(ID); + newReq.setCode("Alphabet Az"); + newReq.setSymbols("A-F"); + newReq.setComment("Testing aZ"); + + String jsonString = getJsonStringForNew(newReq, ID); + addRecordToKafka((MockConsumer) validationSymbolsService.getConsumer(), Consts.DESTINATION_VALIDATE_SYMBOLS_UPDATE, 0, 0, jsonString); + waitingSendAndCheckRecord(ID, mockProducer); + + + ValidationSymbols newValidateSymbols = validationSymbolsIMDG.getSingleObjectByID(ID); + ValidationSymbols vsPrediction = new ValidationSymbols(); + vsPrediction.setId(newValidateSymbols.getId()); + vsPrediction.setCode("Alphabet Az"); + vsPrediction.setSymbols("A-F"); + vsPrediction.setComment("Testing aZ"); + VS_MATCHER.assertMatch(newValidateSymbols, vsPrediction); + } + + @Test + void onValidateSymbolDeleteRequest() { + Long ID = currentID.getAndIncrement(); + ValidationSymbols vsOld = new ValidationSymbols(); + vsOld.setId(ID); + vsOld.setCode("Alphabet Az"); + vsOld.setSymbols("A-F"); + vsOld.setComment("Testing aZ"); + validationSymbolsIMDG.insert(vsOld); + + CommonIdRequest deleteReq = new CommonIdRequest(); + deleteReq.setId(ID); + + String jsonString = getJsonStringForNew(deleteReq, ID); + addRecordToKafka((MockConsumer) validationSymbolsService.getConsumer(), Consts.DESTINATION_VALIDATE_SYMBOLS_DELETE, 0, 0, jsonString); + waitingSendAndCheckRecord(ID, mockProducer); + + + ValidationSymbols newValidateSymbols = validationSymbolsIMDG.getSingleObjectByID(ID); + assertNull(newValidateSymbols); + } +} \ No newline at end of file diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java index b7dbde28a..77d9f94a5 100644 --- a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java @@ -134,6 +134,11 @@ public interface Consts { String DESTINATION_RATES_NEW = "rates-new"; String DESTINATION_RATES_UPDATE = "rates-update"; + String DESTINATION_VALIDATE_SYMBOLS_NEW = "validate-symbols-new"; + String DESTINATION_VALIDATE_SYMBOLS_UPDATE = "validate-symbols-update"; + String DESTINATION_VALIDATE_SYMBOLS_DELETE = "validate-symbols-delete"; + + String DESTINATION_SDF08_NEW = "s-df-08-new"; String DESTINATION_SDF02_NEW = "s-df-02-new"; diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/misc/ValidationSymbolsNewRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/misc/ValidationSymbolsNewRequest.java new file mode 100644 index 000000000..8a3925d0f --- /dev/null +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/misc/ValidationSymbolsNewRequest.java @@ -0,0 +1,37 @@ +package ru.spcex.clearing.platform.messaging.domain.cud.misc; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class ValidationSymbolsNewRequest { + @JsonProperty + private String code; + @JsonProperty + private String symbols; + @JsonProperty + private String comment; + + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public String getSymbols() { + return symbols; + } + + public void setSymbols(String symbols) { + this.symbols = symbols; + } + + public String getComment() { + return comment; + } + + public void setComment(String comment) { + this.comment = comment; + } +} diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/misc/ValidationSymbolsUpdateRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/misc/ValidationSymbolsUpdateRequest.java new file mode 100644 index 000000000..2650ac416 --- /dev/null +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/misc/ValidationSymbolsUpdateRequest.java @@ -0,0 +1,47 @@ +package ru.spcex.clearing.platform.messaging.domain.cud.misc; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class ValidationSymbolsUpdateRequest { + @JsonProperty + private Long id; + @JsonProperty + private String code; + @JsonProperty + private String symbols; + @JsonProperty + private String comment; + + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public String getSymbols() { + return symbols; + } + + public void setSymbols(String symbols) { + this.symbols = symbols; + } + + public String getComment() { + return comment; + } + + public void setComment(String comment) { + this.comment = comment; + } +}