From 93d707961c4152a1f5028c512c287c8e4889c4f7 Mon Sep 17 00:00:00 2001 From: akulikov Date: Wed, 3 May 2023 17:47:19 +0300 Subject: [PATCH 1/9] TradingClearingRegistryService in progress --- ...adingClearingRegistryValidationConfig.java | 130 +++++++++++++ .../config/validation/ValidationConfig.java | 2 + .../clearing/account/errors/AccountError.java | 3 +- .../TradingClearingRegistryService.java | 179 ++++++++++++++++++ .../TradingClearingRegistryController.java | 4 +- ...TradingClearingRegistryControllerTest.java | 4 +- .../registry/TradingClearingRegistry.java | 1 + .../TradingClearingRegistryPurpose.java | 20 ++ .../platform/messaging/domain/Consts.java | 2 +- 9 files changed, 339 insertions(+), 6 deletions(-) create mode 100644 clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java create mode 100644 clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java create mode 100644 platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/TradingClearingRegistryPurpose.java diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java new file mode 100644 index 000000000..4cfd24e05 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java @@ -0,0 +1,130 @@ +package ru.spcex.clearing.account.config.validation; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.clearing.platform.dictionary.WorkflowStatusDictionary; +import ru.spcex.clearing.account.errors.AccountError; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest; +import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; +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.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 TradingClearingRegistryValidationConfig { + @Bean("tradingClearingRegistryNewRequest") + public Function tradingClearingRegistryNewRequestValidator( + Map> imdgForValidation + ) { + return tradingClearingRegistryNewRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(tradingClearingRegistryNewRequest); + Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_Company); + addImdg.accept(IMDGDistributedNames.Map_Account); + addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary); + return new ValidatorImpl<>(context, + IdPresentRule.instance("companyId", + TradingClearingRegistryNewRequest::getCompanyId, + IMDGDistributedNames.Map_Company, + Company.class, + AccountError.RequiredFieldEmpty, + AccountError.CompanyNotFound), + FieldRequiredRule.instance("moneyAccountId", + TradingClearingRegistryNewRequest::getMoneyAccountId, + AccountError.RequiredFieldEmpty, + moneyAccountId -> { + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Account account = accountImdg.getSingleObjectByID(moneyAccountId); + if (account == null) return AccountError.AccountNotFound; + return null; + }), + FieldRequiredRule.instance("depoAccountId", + TradingClearingRegistryNewRequest::getDepoAccountId, + AccountError.RequiredFieldEmpty, + false, + depoAccountId -> { + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Account account = accountImdg.getSingleObjectByID(depoAccountId); + if (account == null) return AccountError.AccountNotFound; + return null; + }), + DictionaryPresentRule.instance("status", + TradingClearingRegistryNewRequest::getStatus, + IMDGDistributedNames.Map_WorkflowStatusDictionary, + WorkflowStatusDictionary.class, + AccountError.RequiredFieldEmpty, + AccountError.WrongFieldValue, + false, + statusValue -> { + String statusCode = statusValue.getCode(); + if (WorkflowStatus.Active.equalsByKey(statusCode)) return null; + return AccountError.WrongFieldValue; + }) + ); + }; + } + + @Bean("tradingClearingRegistryUpdateRequest") + public Function tradingClearingRegistryUpdateRequestValidator( + Map> imdgForValidation + ) { + return tradingClearingRegistryUpdateRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(tradingClearingRegistryUpdateRequest); + Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary); + addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry); + return new ValidatorImpl<>(context, + IdPresentRule.instance("id", + TradingClearingRegistryUpdateRequest::getId, + IMDGDistributedNames.Map_TradingClearingRegistry, + TradingClearingRegistry.class, + AccountError.RequiredFieldEmpty, + AccountError.TradingClearingRegistryNotFound), + DictionaryPresentRule.instance("status", + TradingClearingRegistryUpdateRequest::getStatus, + IMDGDistributedNames.Map_WorkflowStatusDictionary, + WorkflowStatusDictionary.class, + AccountError.RequiredFieldEmpty, + AccountError.WrongFieldValue, + false) + ); + }; + } + + @Bean("tradingClearingRegistryBlockRequest") + public Function tradingClearingRegistryBlockRequestValidator( + Map> imdgForValidation + ) { + return tradingClearingRegistryBlockRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(tradingClearingRegistryBlockRequest); + Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry); + return new ValidatorImpl<>(context, + IdPresentRule.instance("id", + CommonDeleteRequest::getId, + IMDGDistributedNames.Map_TradingClearingRegistry, + TradingClearingRegistry.class, + AccountError.RequiredFieldEmpty, + AccountError.TradingClearingRegistryNotFound) + ); + }; + } +} diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java index 36cebc49d..e9d50af15 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java @@ -11,6 +11,7 @@ import ru.clearing.classes.statics.data.company.ClearingMemberCategory; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary; import ru.clearing.platform.dictionary.CurrencyCodeDictionary; +import ru.clearing.platform.dictionary.WorkflowStatusDictionary; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.platform.classes.base.SpcexObjectBase; @@ -39,6 +40,7 @@ public class ValidationConfig { addImdg.accept(IMDGDistributedNames.Map_BankAccount, BankAccount.class); addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary, CurrencyCodeDictionary.class); addImdg.accept(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); + addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary, WorkflowStatusDictionary.class); return imdg; } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java index 82789613d..7a4b12852 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java @@ -12,7 +12,8 @@ public enum AccountError implements IErrorEnumId { CompanyNotFound(5013L), CompanyNotActive(5014L), InfoAccountAlreadyExist(5015L), - ClearingCategoryNotFound(5019L) + ClearingCategoryNotFound(5019L), + TradingClearingRegistryNotFound(5022L), ; private final Long id; diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java new file mode 100644 index 000000000..43a903066 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -0,0 +1,179 @@ +package ru.spcex.clearing.account.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.Qualifier; +import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.account.ClearingAccount; +import ru.clearing.classes.statics.data.account.DepoAccount; +import ru.clearing.classes.statics.data.company.Company; +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.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest; +import ru.spcex.clearing.platform.messaging.service.QueueConsumer; +import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; +import ru.spcex.clearing.util.security.UserRoleVerification; +import ru.spcex.clearing.validation.common.ValidationHelper; +import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose; +import ru.spcex.platform.enumeration.WorkflowStatus; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.utils.validation.IValidator; + +import java.time.Instant; +import java.util.function.Function; + +@Service +public class TradingClearingRegistryService extends QueueConsumer implements InitializingBean { + private final Logger log = LoggerFactory.getLogger(getClass()); + + private final ValidationHelper validationHelper; + private final UserRoleVerification userRoleVerification; + + private final Imdg tradingClearingRegistryImdg; + private final Imdg depoAccountImdg; + private final Imdg clearingAccountImdg; + private final Imdg companyImdg; + + private final Function tradingClearingRegistryUpdateRequestValidator; + private final Function tradingClearingRegistryNewRequestValidator; + private final Function tradingClearingRegistryBlockRequestValidator; + + public TradingClearingRegistryService(Consumer kafkaQueue, + Producer kafkaProducer, + ImdgProvider imdgProvider, + ValidationHelper validationHelper, + UserRoleVerification userRoleVerification, + @Qualifier("tradingClearingRegistryNewRequest") + Function tradingClearingRegistryNewRequestValidator, + @Qualifier("tradingClearingRegistryUpdateRequest") + Function tradingClearingRegistryUpdateRequestValidator, + @Qualifier("tradingClearingRegistryBlockRequest") + Function tradingClearingRegistryBlockRequestValidator) { + super(kafkaQueue, kafkaProducer); + this.validationHelper = validationHelper; + this.userRoleVerification = userRoleVerification; + this.tradingClearingRegistryNewRequestValidator = tradingClearingRegistryNewRequestValidator; + this.tradingClearingRegistryImdg = imdgProvider.getImdg( + IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class + ); + this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class); + this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); + this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + this.tradingClearingRegistryUpdateRequestValidator = tradingClearingRegistryUpdateRequestValidator; + this.tradingClearingRegistryBlockRequestValidator = tradingClearingRegistryBlockRequestValidator; + } + + @Override + public void afterPropertiesSet() throws Exception { + init(); + callback(TradingClearingRegistryNewRequest.class) + .setConsumer(this::tradingClearingRegistryNew) + .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, callbacks::put); + callback(TradingClearingRegistryUpdateRequest.class) + .setConsumer(this::tradingClearingRegistryUpdate) + .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE, callbacks::put); + callback(CommonDeleteRequest.class) + .setConsumer(this::tradingClearingRegistryBlock) + .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put); + } + + public RequestInfoUpdate tradingClearingRegistryNew(BaseRequest userRequest) { + log.debug("TradingClearingRegistryNewRequest received"); + RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); + if (requestInfoUpdate != null) return requestInfoUpdate; + + requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryNewRequestValidator); + if (requestInfoUpdate != null) return requestInfoUpdate; + + TradingClearingRegistryNewRequest req = userRequest.getRequestPayload(); + + Long id = tradingClearingRegistryImdg.nextIDSequenceFor(); + TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry(); + tradingClearingRegistry.setId(id); + tradingClearingRegistry.setCompanyId(req.getCompanyId()); + tradingClearingRegistry.setMoneyAccountId(req.getMoneyAccountId()); + tradingClearingRegistry.setDepoAaccountId(req.getDepoAccountId()); + tradingClearingRegistry.setStatus(WorkflowStatus.Active.getKey()); + + // todo tradingClearingRegistryType из соответствующего параметра очереди но в запросе он не фигурирует + // пока оставил вычисление аналогичное автоматическому добавлению ТКР + String tradingRegistryType; + if (req.getDepoAccountId() != null) { + DepoAccount depoAccount = depoAccountImdg.getSingleObjectByID(req.getDepoAccountId()); + tradingRegistryType = depoAccount.getDepoAccountType(); + } else { + ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); + tradingRegistryType = clearingAccount.getClearingAccountType(); + } + tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType); + + TradingClearingRegistryPurpose registryPurpose; + if (req.getDepoAccountId() != null) registryPurpose = TradingClearingRegistryPurpose.C; + else registryPurpose = TradingClearingRegistryPurpose.M; + tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey()); + + Company company = companyImdg.getSingleObjectByID(req.getCompanyId()); + String code = company.getClearingCode() + registryPurpose.getKey() + registryPurpose; + if (registryPurpose == TradingClearingRegistryPurpose.C) code += tradingRegistryType + id; + else code += "AT" + id; + tradingClearingRegistry.setCode(code); + + Instant now = Instant.now(); + tradingClearingRegistry.setCreated(now); + tradingClearingRegistry.setUpdated(now); + + tradingClearingRegistryImdg.insert(tradingClearingRegistry); + + log.debug("successfully processed, id {}", id); + return null; + } + + public RequestInfoUpdate tradingClearingRegistryUpdate(BaseRequest userRequest) { + log.debug("TradingClearingRegistryUpdateRequest received"); + RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); + if (requestInfoUpdate != null) return requestInfoUpdate; + + requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryUpdateRequestValidator); + if (requestInfoUpdate != null) return requestInfoUpdate; + + TradingClearingRegistryUpdateRequest req = userRequest.getRequestPayload(); + TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId()); + + if (req.getStatus() != null) tradingClearingRegistry.setStatus(req.getStatus()); + + Instant now = Instant.now(); + tradingClearingRegistry.setUpdated(now); + + tradingClearingRegistryImdg.update(tradingClearingRegistry); + + log.debug("successfully processed, id {}", tradingClearingRegistry.getId()); + return null; + } + + public RequestInfoUpdate tradingClearingRegistryBlock(BaseRequest userRequest) { + log.debug("TradingClearingRegistryBlockRequest received"); + RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); + if (requestInfoUpdate != null) return requestInfoUpdate; + + requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryBlockRequestValidator); + if (requestInfoUpdate != null) return requestInfoUpdate; + + CommonDeleteRequest req = userRequest.getRequestPayload(); + TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId()); + + tradingClearingRegistry.setStatus(WorkflowStatus.Blocked.getKey()); + + tradingClearingRegistryImdg.update(tradingClearingRegistry); + + log.debug("successfully processed, id {}", tradingClearingRegistry.getId()); + return null; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryController.java index 0d984ff0f..50c5984ab 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryController.java @@ -10,9 +10,9 @@ import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.*; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController; +import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction; import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryNewAction; import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryUpdateAction; -import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction; import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse; import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse; import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; @@ -69,7 +69,7 @@ public class TradingClearingRegistryController extends AbstractQueueController { @PathVariable("id") Long id) throws ExecutionException, InterruptedException { CommonDeleteAction deleteAction = new CommonDeleteAction(); deleteAction.setId(id); - return processRequest(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_DELETE, deleteAction); + return processRequest(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, deleteAction); } @ApiOperation(value = "get TradingClearingRegistry by id.") diff --git a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryControllerTest.java b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryControllerTest.java index c45ddd2ed..be9151b6b 100644 --- a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryControllerTest.java +++ b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryControllerTest.java @@ -6,9 +6,9 @@ import org.springframework.http.MediaType; import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest; +import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction; import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryNewAction; import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryUpdateAction; -import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction; import ru.spcex.clearing.backendapi.controller.response.entity.registry.TradingClearingRegistryBackendGetById; import ru.spcex.clearing.backendapi.controller.response.entity.registry.TradingClearingRegistryBackendGetFields; import ru.spcex.clearing.backendapi.domain.actions.IAction; @@ -97,7 +97,7 @@ class TradingClearingRegistryControllerTest extends AbstractControllerTest { deleteAction.setId(id); //ACT and ASSERT checkDeletingByRestApi(REST_URL, id); - checkSendedMessegeFromKafka(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_DELETE, deleteAction); + checkSendedMessegeFromKafka(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, deleteAction); } /** diff --git a/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/registry/TradingClearingRegistry.java b/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/registry/TradingClearingRegistry.java index 9fa9a6050..91bb3ca6f 100644 --- a/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/registry/TradingClearingRegistry.java +++ b/clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/registry/TradingClearingRegistry.java @@ -15,6 +15,7 @@ public class TradingClearingRegistry extends BusinessObject { private Long companyId; private String code; private Long moneyAccountId; + // todo fix typo private Long depoAaccountId; private String tradingClearingRegistryType; private String tradingClearingRegistryLevel; diff --git a/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/TradingClearingRegistryPurpose.java b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/TradingClearingRegistryPurpose.java new file mode 100644 index 000000000..724d5519d --- /dev/null +++ b/platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/TradingClearingRegistryPurpose.java @@ -0,0 +1,20 @@ +package ru.spcex.platform.enumeration; + +import ru.spcex.platform.utils.enumeration.IEnumKey; + +public enum TradingClearingRegistryPurpose implements IEnumKey { + M("M"), + C("C"), + ; + + private final String key; + + TradingClearingRegistryPurpose(String key) { + this.key = key; + } + + @Override + public String getKey() { + return key; + } +} 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 9842d71ef..4a9861ffd 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 @@ -83,7 +83,7 @@ public interface Consts { String DESTINATION_TRADING_CLEARING_REGISTRY_NEW = "trading-clearing-registry-new"; String DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE = "trading-clearing-registry-update"; - String DESTINATION_TRADING_CLEARING_REGISTRY_DELETE = "trading-clearing-registry-delete"; + String DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK = "trading-clearing-registry-block"; String DESTINATION_SDF08_NEW = "s-df-08-new"; String DESTINATION_SDF02_NEW = "s-df-02-new"; From 71203b08e78906e58ce7d55b7758e19c62da4295 Mon Sep 17 00:00:00 2001 From: akulikov Date: Fri, 5 May 2023 09:51:10 +0300 Subject: [PATCH 2/9] http://jira.mfd.msk:8088/browse/CLS-271 fix statuses --- .../validation/AccountValidationConfig.java | 27 ++++--- .../BankAccountValidationConfig.java | 3 +- .../ClearingAccountValidationConfig.java | 6 +- .../DepoAccountValidationConfig.java | 4 +- ...adingClearingRegistryValidationConfig.java | 73 ++++++++++++++++++- .../config/validation/ValidationConfig.java | 4 +- .../account/service/AccountService.java | 4 +- .../account/service/BankAccountService.java | 6 +- .../service/ClearingAccountService.java | 12 +-- .../account/service/DepoAccountService.java | 4 +- .../service/InformationAccountService.java | 4 +- .../TradingClearingRegistryService.java | 13 ++++ .../account/service/AccountServiceTest.java | 21 ++++-- .../service/ClearingAccountServiceTest.java | 6 +- .../service/DepoAccountServiceTest.java | 2 +- .../InformationAccountServiceTest.java | 2 +- .../platform/messaging/domain/Consts.java | 1 + 17 files changed, 144 insertions(+), 48 deletions(-) diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java index cb654bc0e..8f9cd76eb 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java @@ -5,18 +5,19 @@ import org.springframework.context.annotation.Configuration; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.platform.dictionary.AccountTypeDictionary; +import ru.clearing.platform.dictionary.ServiceStatusDictionary; import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountUpdateRequest; import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; -import ru.spcex.clearing.validation.common.rules.EnumPresentRule; 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.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; @@ -45,6 +46,7 @@ public class AccountValidationConfig { Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); addImdg.accept(IMDGDistributedNames.Map_Company); addImdg.accept(IMDGDistributedNames.Map_Account); + addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary); addImdg.accept(IMDGDistributedNames.Map_AccountTypeDictionary); return new ValidatorImpl<>(context, IdPresentRule.instance("companyId", @@ -69,12 +71,15 @@ public class AccountValidationConfig { if (accounts.isEmpty()) return null; return AccountError.AccountAlreadyExist; }), - FieldRequiredRule.instance("status", + DictionaryPresentRule.instance("status", CorrespondentAccountNewRequest::getStatus, + IMDGDistributedNames.Map_ServiceStatusDictionary, + ServiceStatusDictionary.class, AccountError.RequiredFieldEmpty, + AccountError.WrongFieldValue, false, statusValue -> { - if (statusValue == null || AccountStatus.ACTIVE.equalsByKey(statusValue)) return null; + if (ServiceStatus.Active.equalsByKey(statusValue.getCode())) return null; return AccountError.WrongFieldValue; }), DictionaryPresentRule.instance("accountType", @@ -127,16 +132,16 @@ public class AccountValidationConfig { error = Objects.equals(company.getId(), correspondentAccountUpdateRequest.getCompanyId()) ? error : AccountError.WrongFieldValue; return error; }), - EnumPresentRule.instance("status", + DictionaryPresentRule.instance("status", CorrespondentAccountUpdateRequest::getStatus, - AccountStatus.values(), - false, - AccountError.WrongFieldValue, - AccountError.RequiredFieldEmpty), + IMDGDistributedNames.Map_ServiceStatusDictionary, + ServiceStatusDictionary.class, + AccountError.RequiredFieldEmpty, + AccountError.WrongFieldValue), DictionaryPresentRule.instance("accountType", CorrespondentAccountUpdateRequest::getAccountType, - IMDGDistributedNames.Map_AccountTypeDictionary, - AccountTypeDictionary.class, + IMDGDistributedNames.Map_ServiceStatusDictionary, + ServiceStatusDictionary.class, AccountError.RequiredFieldEmpty, AccountError.WrongFieldValue, accountType -> { @@ -164,7 +169,7 @@ public class AccountValidationConfig { AccountError.RequiredFieldEmpty, AccountError.AccountNotFound, account -> { - if (AccountStatus.ACTIVE.equalsByKey(account.getStatus())) return null; + if (WorkflowStatus.Active.equalsByKey(account.getStatus())) return null; return AccountError.AccountNotActive; }) ); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java index 1c2ca6ab6..c4c350bb4 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java @@ -17,6 +17,7 @@ import ru.spcex.clearing.validation.common.rules.IdPresentRule; import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; @@ -62,7 +63,7 @@ public class BankAccountValidationConfig { ); ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); ImdgPredicate accountValuePredicate = pb.equals("account", accountValue); - ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey()); + ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey()); ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Bank.getKey()); ImdgPredicate finalPredicate = pb.and(accountValuePredicate, accountStatusPredicate, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java index cb3c2368e..9c9cb0ba6 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java @@ -13,8 +13,8 @@ import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; 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.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; @@ -60,7 +60,7 @@ public class ClearingAccountValidationConfig { ); ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); ImdgPredicate accountValuePredicate = pb.equals("account", accountValue); - ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey()); + ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey()); ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey()); ImdgPredicate finalPredicate = pb.and(accountValuePredicate, accountStatusPredicate, @@ -102,7 +102,7 @@ public class ClearingAccountValidationConfig { ); ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); ImdgPredicate accountValuePredicate = pb.equals("account", accountValue); - ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey()); + ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey()); ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey()); ImdgPredicate finalPredicate = pb.and(accountValuePredicate, accountStatusPredicate, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/DepoAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/DepoAccountValidationConfig.java index 10277912b..c3bbca5ff 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/DepoAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/DepoAccountValidationConfig.java @@ -10,8 +10,8 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.DepoAccountNewReq 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.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; @@ -56,7 +56,7 @@ public class DepoAccountValidationConfig { ); ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); ImdgPredicate accountValuePredicate = pb.equals("account", accountValue); - ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey()); + ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey()); ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey()); ImdgPredicate finalPredicate = pb.and(accountValuePredicate, accountStatusPredicate, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java index 4cfd24e05..27e0c6581 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java @@ -5,6 +5,7 @@ import org.springframework.context.annotation.Configuration; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.clearing.platform.dictionary.ServiceStatusDictionary; import ru.clearing.platform.dictionary.WorkflowStatusDictionary; import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; @@ -15,6 +16,7 @@ import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; 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.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.validation.ImdgValidationContext; @@ -27,6 +29,71 @@ import java.util.function.Function; @Configuration public class TradingClearingRegistryValidationConfig { + @Bean("tradingClearingRegistryAutoNewRequest") + public Function tradingClearingRegistryAutoNewRequestValidator( + Map> imdgForValidation + ) { + return tradingClearingRegistryAutoNewRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(tradingClearingRegistryAutoNewRequest); + Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_Company); + addImdg.accept(IMDGDistributedNames.Map_Account); + addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary); + return new ValidatorImpl<>(context, + IdPresentRule.instance("companyId", + TradingClearingRegistryNewRequest::getCompanyId, + IMDGDistributedNames.Map_Company, + Company.class, + AccountError.RequiredFieldEmpty, + AccountError.CompanyNotFound), + FieldRequiredRule.instance("moneyAccountId", + TradingClearingRegistryNewRequest::getMoneyAccountId, + AccountError.RequiredFieldEmpty, + moneyAccountId -> { + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Account account = accountImdg.getSingleObjectByID(moneyAccountId); + if (account == null) return AccountError.AccountNotFound; + return null; + }), + FieldRequiredRule.instance("depoAccountId", + TradingClearingRegistryNewRequest::getDepoAccountId, + AccountError.RequiredFieldEmpty, + false, + depoAccountId -> { + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Account account = accountImdg.getSingleObjectByID(depoAccountId); + if (account == null) return AccountError.AccountNotFound; + return null; + }), + DictionaryPresentRule.instance("status", + TradingClearingRegistryNewRequest::getStatus, + IMDGDistributedNames.Map_ServiceStatusDictionary, + ServiceStatusDictionary.class, + AccountError.RequiredFieldEmpty, + AccountError.WrongFieldValue, + false, + statusValue -> { + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Long moneyAccountId = tradingClearingRegistryAutoNewRequest.getMoneyAccountId(); + Long depoAccountId = tradingClearingRegistryAutoNewRequest.getDepoAccountId(); + Account moneyAccount = accountImdg.getSingleObjectByID(moneyAccountId); + Account depoAccount = depoAccountId != null ? accountImdg.getSingleObjectByID(depoAccountId) : null; + if ( + (depoAccount != null && (ServiceStatus.Active.equalsByKey(depoAccount.getStatus()) || ServiceStatus.Reopened.equalsByKey(depoAccount.getStatus()))) && + (ServiceStatus.Active.equalsByKey(moneyAccount.getStatus()) || ServiceStatus.Reopened.equalsByKey(moneyAccount.getStatus())) + ) { + + } + + String statusCode = statusValue.getCode(); + if (WorkflowStatus.Active.equalsByKey(statusCode)) return null; + return AccountError.WrongFieldValue; + }) + ); + }; + } + @Bean("tradingClearingRegistryNewRequest") public Function tradingClearingRegistryNewRequestValidator( Map> imdgForValidation @@ -66,14 +133,14 @@ public class TradingClearingRegistryValidationConfig { }), DictionaryPresentRule.instance("status", TradingClearingRegistryNewRequest::getStatus, - IMDGDistributedNames.Map_WorkflowStatusDictionary, - WorkflowStatusDictionary.class, + IMDGDistributedNames.Map_ServiceStatusDictionary, + ServiceStatusDictionary.class, AccountError.RequiredFieldEmpty, AccountError.WrongFieldValue, false, statusValue -> { String statusCode = statusValue.getCode(); - if (WorkflowStatus.Active.equalsByKey(statusCode)) return null; + if (ServiceStatus.Active.equalsByKey(statusCode)) return null; return AccountError.WrongFieldValue; }) ); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java index 43cbba292..fd41493df 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java @@ -12,7 +12,7 @@ import ru.clearing.classes.statics.data.company.Company; import ru.clearing.platform.dictionary.AccountTypeDictionary; import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary; import ru.clearing.platform.dictionary.CurrencyCodeDictionary; -import ru.clearing.platform.dictionary.WorkflowStatusDictionary; +import ru.clearing.platform.dictionary.ServiceStatusDictionary; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.platform.classes.base.SpcexObjectBase; @@ -41,7 +41,7 @@ public class ValidationConfig { addImdg.accept(IMDGDistributedNames.Map_BankAccount, BankAccount.class); addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary, CurrencyCodeDictionary.class); addImdg.accept(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); - addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary, WorkflowStatusDictionary.class); + addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class); return imdg; } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java index 81df09673..fdc36e84d 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java @@ -28,8 +28,8 @@ import ru.spcex.clearing.platform.messaging.service.Status; 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.AccountStatus; import ru.spcex.platform.enumeration.ClearingCategory; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; @@ -173,7 +173,7 @@ public class AccountService extends QueueConsumer implements InitializingBean { CommonDeleteRequest request = userRequest.getRequestPayload(); Account account = accountMap.getSingleObjectByID(request.getId()); - account.setStatus(AccountStatus.BLOCKED.getKey()); + account.setStatus(ServiceStatus.Blocked.getKey()); account.setUpdated(Instant.now()); accountMap.update(account); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java index 1940cc5a9..de0fb0be8 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java @@ -20,8 +20,8 @@ import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.validation.common.ValidationHelper; -import ru.spcex.platform.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgTransaction; @@ -101,7 +101,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea Account account = new Account(); account.setAccount(req.getAccount()); account.setAccountType(AccountType.Bank.getKey()); - account.setStatus(AccountStatus.ACTIVE.getKey()); + account.setStatus(ServiceStatus.Active.getKey()); account.setCompanyId(req.getCompanyId()); account.setCreated(now); account.setUpdated(now); @@ -207,7 +207,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea BankAccount bankAccount = bankAccountMap.getSingleObjectByID(req.getId()); Account account = accountMap.getSingleObjectByID(bankAccount.getAccountId()); - account.setStatus(AccountStatus.BLOCKED.getKey()); + account.setStatus(ServiceStatus.Blocked.getKey()); account.setUpdated(Instant.now()); ImdgTransaction imdgTransaction = imdgProvider.newTransaction(); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java index 03f148353..a4ceddaa6 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java @@ -20,8 +20,8 @@ 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.validation.common.ValidationHelper; -import ru.spcex.platform.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgTransaction; @@ -92,7 +92,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin Account account = new Account(); account.setAccount(req.getAccount()); account.setAccountType(AccountType.Clrn.getKey()); - account.setStatus(AccountStatus.ACTIVE.getKey()); + account.setStatus(ServiceStatus.Active.getKey()); account.setCompanyId(req.getCompanyId()); account.setCreated(now); account.setUpdated(now); @@ -137,7 +137,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin ClearingAccountUpdateRequest req = userRequest.getRequestPayload(); ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); ImdgPredicate accountValuePredicate = pb.equals("account", req.getAccount()); - ImdgPredicate accountStatusPredicate = pb.equals("status", AccountStatus.ACTIVE.getKey()); + ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey()); ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey()); ImdgPredicate finalPredicate = pb.and(accountValuePredicate, accountStatusPredicate, @@ -156,9 +156,9 @@ public class ClearingAccountService extends QueueConsumer implements Initializin } Integer statusValue = req.getStatus(); - if (statusValue == 0) account.setStatus(AccountStatus.BLOCKED.getKey()); - else if (statusValue == 1) account.setStatus(AccountStatus.ACTIVE.getKey()); - else if (statusValue == 2) account.setStatus(AccountStatus.CLOSE.getKey()); + if (statusValue == 0) account.setStatus(ServiceStatus.Blocked.getKey()); + else if (statusValue == 1) account.setStatus(ServiceStatus.Active.getKey()); + else if (statusValue == 2) account.setStatus(ServiceStatus.Closed.getKey()); account.setUpdated(Instant.now()); accountImdg.update(account); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java index 625e909f5..719820108 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java @@ -16,8 +16,8 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.DepoAccountNewReq import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.validation.common.ValidationHelper; -import ru.spcex.platform.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgTransaction; @@ -74,7 +74,7 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea Account account = new Account(); account.setAccount(req.getAccount()); account.setAccountType(AccountType.Depo.getKey()); - account.setStatus(AccountStatus.ACTIVE.getKey()); + account.setStatus(ServiceStatus.Active.getKey()); account.setCompanyId(req.getCompanyId()); account.setCreated(now); account.setUpdated(now); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java index 2c74b2086..5bb94636b 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java @@ -19,8 +19,8 @@ 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.validation.common.ValidationHelper; -import ru.spcex.platform.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgTransaction; @@ -105,7 +105,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali Account account = new Account(); account.setAccount(accountValue); account.setAccountType(AccountType.Info.getKey()); - account.setStatus(AccountStatus.ACTIVE.getKey()); + account.setStatus(ServiceStatus.Active.getKey()); account.setCompanyId(userRequest.getRequestPayload().getCompanyId()); account.setCreated(now); account.setUpdated(now); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java index 43a903066..cec060ea0 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -74,6 +74,9 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini @Override public void afterPropertiesSet() throws Exception { init(); + callback(TradingClearingRegistryNewRequest.class) + .setConsumer(this::tradingClearingRegistryAutoNew) + .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, callbacks::put); callback(TradingClearingRegistryNewRequest.class) .setConsumer(this::tradingClearingRegistryNew) .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, callbacks::put); @@ -85,6 +88,16 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put); } + public RequestInfoUpdate tradingClearingRegistryAutoNew(BaseRequest userRequest) { + log.debug("TradingClearingRegistryAutoNewRequest received"); + + + + Long id = null; + log.debug("successfully processed, id {}", id); + return null; + } + public RequestInfoUpdate tradingClearingRegistryNew(BaseRequest userRequest) { log.debug("TradingClearingRegistryNewRequest received"); RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/AccountServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/AccountServiceTest.java index b2d53c3dc..e0e7383b0 100644 --- a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/AccountServiceTest.java +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/AccountServiceTest.java @@ -19,6 +19,7 @@ import ru.clearing.classes.statics.data.company.ClearingMemberCategory; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.company.relation.Relation; import ru.clearing.platform.dictionary.AccountTypeDictionary; +import ru.clearing.platform.dictionary.ServiceStatusDictionary; import ru.spcex.clearing.account.config.BeanConfiguration; import ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration; import ru.spcex.clearing.account.config.KafkaConfigTest; @@ -87,6 +88,7 @@ class AccountServiceTest { private Imdg accountTypeDictionaryImdg; private Imdg clearingMemberCategoryImdg; private Imdg relationImdg; + private Imdg serviceStatusDictionaryImdg; @PostConstruct private void init() { @@ -106,6 +108,13 @@ class AccountServiceTest { relationImdg = hazelcastServiceTest.getImdg( IMDGDistributedNames.Map_Relation, Relation.class ); + serviceStatusDictionaryImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class + ); + ServiceStatusDictionary serviceStatusDictionary = new ServiceStatusDictionary(); + serviceStatusDictionary.setCode(ServiceStatus.Active.getKey()); + serviceStatusDictionary.setName(ServiceStatus.Active.getKey()); + serviceStatusDictionaryImdg.insert(serviceStatusDictionary); Company company = new Company(); company.setId(companyId); @@ -137,13 +146,13 @@ class AccountServiceTest { correspondentAccountNewRequest.setAccount(uniqueAccount); correspondentAccountNewRequest.setAccountType(AccountType.Corr.getKey()); correspondentAccountNewRequest.setCompanyId(companyId); - correspondentAccountNewRequest.setStatus(AccountStatus.ACTIVE.getKey()); + correspondentAccountNewRequest.setStatus(ServiceStatus.Active.getKey()); Account predictableAccount = new Account(); predictableAccount.setAccount(uniqueAccount); predictableAccount.setAccountType(AccountType.Corr.getKey()); predictableAccount.setCompanyId(companyId); - predictableAccount.setStatus(AccountStatus.ACTIVE.getKey()); + predictableAccount.setStatus(ServiceStatus.Active.getKey()); predictableAccount.setRelationId(relationId); String jsonString = getJsonStringForNew(correspondentAccountNewRequest, 0L); @@ -169,14 +178,14 @@ class AccountServiceTest { Account existAccount = new Account(); existAccount.setAccount(account); existAccount.setAccountType(AccountType.Corr.getKey()); - existAccount.setStatus(AccountStatus.CLOSE.getKey()); + existAccount.setStatus(ServiceStatus.Closed.getKey()); existAccount.setCompanyId(companyId); Long accountId = accountImdg.insert(existAccount); CorrespondentAccountUpdateRequest correspondentAccountUpdateRequest = new CorrespondentAccountUpdateRequest(); correspondentAccountUpdateRequest.setAccount(account); correspondentAccountUpdateRequest.setAccountType(AccountType.Corr.getKey()); - correspondentAccountUpdateRequest.setStatus(AccountStatus.ACTIVE.getKey()); + correspondentAccountUpdateRequest.setStatus(ServiceStatus.Active.getKey()); correspondentAccountUpdateRequest.setCompanyId(companyId); correspondentAccountUpdateRequest.setId(accountId); @@ -204,7 +213,7 @@ class AccountServiceTest { Account existAccount = new Account(); existAccount.setAccount(account); existAccount.setAccountType(AccountType.Corr.getKey()); - existAccount.setStatus(AccountStatus.ACTIVE.getKey()); + existAccount.setStatus(ServiceStatus.Active.getKey()); existAccount.setCompanyId(companyId); Long accountId = accountImdg.insert(existAccount); @@ -224,7 +233,7 @@ class AccountServiceTest { waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); Account resultBlock = accountImdg.getSingleObjectByID(accountId); - existAccount.setStatus(AccountStatus.BLOCKED.getKey()); + existAccount.setStatus(ServiceStatus.Blocked.getKey()); existAccount.setUpdated(resultBlock.getUpdated()); ACCOUNT_MATCHER.assertMatch(existAccount, resultBlock); diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java index da67ac384..45509b2c8 100644 --- a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java @@ -156,7 +156,7 @@ class ClearingAccountServiceTest { Account predictableAccount = new Account(); predictableAccount.setAccount(ACCOUNT_VALUE); predictableAccount.setAccountType(AccountType.Clrn.getKey()); - predictableAccount.setStatus(AccountStatus.ACTIVE.getKey()); + predictableAccount.setStatus(ServiceStatus.Active.getKey()); predictableAccount.setRelationId(relationId); predictableAccount.setCompanyId(companyId); @@ -182,7 +182,7 @@ class ClearingAccountServiceTest { void clearingAccountUpdate() { Account existAccount = new Account(); existAccount.setAccount(ACCOUNT_VALUE); - existAccount.setStatus(AccountStatus.ACTIVE.getKey()); + existAccount.setStatus(ServiceStatus.Active.getKey()); existAccount.setAccountType(AccountType.Clrn.getKey()); Long accountId = accountImdg.insert(existAccount); @@ -193,7 +193,7 @@ class ClearingAccountServiceTest { Account predictableAccount = new Account(); predictableAccount.setAccount(ACCOUNT_VALUE); - predictableAccount.setStatus(AccountStatus.BLOCKED.getKey()); + predictableAccount.setStatus(ServiceStatus.Blocked.getKey()); predictableAccount.setAccountType(AccountType.Clrn.getKey()); clearingAccountImdg.insert(existClearingAccount); diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/DepoAccountServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/DepoAccountServiceTest.java index 0d6ea0bcb..79dd222f8 100644 --- a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/DepoAccountServiceTest.java +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/DepoAccountServiceTest.java @@ -155,7 +155,7 @@ class DepoAccountServiceTest { Account predictableAccount = new Account(); predictableAccount.setAccount(ACCOUNT_VALUE); predictableAccount.setAccountType(AccountType.Depo.getKey()); - predictableAccount.setStatus(AccountStatus.ACTIVE.getKey()); + predictableAccount.setStatus(ServiceStatus.Active.getKey()); predictableAccount.setRelationId(relationId); predictableAccount.setCompanyId(companyId); diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java index 176245ab5..54879a30b 100644 --- a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java @@ -144,7 +144,7 @@ class InformationAccountServiceTest { Account predictableAccount = new Account(); predictableAccount.setAccountType(AccountType.Info.getKey()); - predictableAccount.setStatus(AccountStatus.ACTIVE.getKey()); + predictableAccount.setStatus(ServiceStatus.Active.getKey()); predictableAccount.setRelationId(relationId); predictableAccount.setCompanyId(companyId); 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 c250e2a6e..d6b06bcf7 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 @@ -81,6 +81,7 @@ public interface Consts { String DESTINATION_CLIENT_CODE_UPDATE = "client-code-update"; String DESTINATION_CLIENT_CODE_DELETE = "client-code-delete"; + String DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW = "trading-clearing-registry-auto-new"; String DESTINATION_TRADING_CLEARING_REGISTRY_NEW = "trading-clearing-registry-new"; String DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE = "trading-clearing-registry-update"; String DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK = "trading-clearing-registry-block"; From 9d1a3784472a3ac0f7c94fdba53b72bdd1e126cb Mon Sep 17 00:00:00 2001 From: akulikov Date: Fri, 5 May 2023 10:45:01 +0300 Subject: [PATCH 3/9] http://jira.mfd.msk:8088/browse/CLS-271 TradingClearingRegistryService --- ...adingClearingRegistryValidationConfig.java | 76 ++--------------- .../TradingClearingRegistryService.java | 83 +++++++++++++------ .../platform/messaging/domain/Consts.java | 1 - 3 files changed, 62 insertions(+), 98 deletions(-) diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java index 27e0c6581..b32ebb6e5 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java @@ -6,7 +6,6 @@ import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.platform.dictionary.ServiceStatusDictionary; -import ru.clearing.platform.dictionary.WorkflowStatusDictionary; import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; @@ -17,7 +16,6 @@ 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.enumeration.ServiceStatus; -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; @@ -29,70 +27,6 @@ import java.util.function.Function; @Configuration public class TradingClearingRegistryValidationConfig { - @Bean("tradingClearingRegistryAutoNewRequest") - public Function tradingClearingRegistryAutoNewRequestValidator( - Map> imdgForValidation - ) { - return tradingClearingRegistryAutoNewRequest -> { - ImdgValidationContext context = new ImdgValidationContext<>(); - context.setValidatedObject(tradingClearingRegistryAutoNewRequest); - Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); - addImdg.accept(IMDGDistributedNames.Map_Company); - addImdg.accept(IMDGDistributedNames.Map_Account); - addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary); - return new ValidatorImpl<>(context, - IdPresentRule.instance("companyId", - TradingClearingRegistryNewRequest::getCompanyId, - IMDGDistributedNames.Map_Company, - Company.class, - AccountError.RequiredFieldEmpty, - AccountError.CompanyNotFound), - FieldRequiredRule.instance("moneyAccountId", - TradingClearingRegistryNewRequest::getMoneyAccountId, - AccountError.RequiredFieldEmpty, - moneyAccountId -> { - Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); - Account account = accountImdg.getSingleObjectByID(moneyAccountId); - if (account == null) return AccountError.AccountNotFound; - return null; - }), - FieldRequiredRule.instance("depoAccountId", - TradingClearingRegistryNewRequest::getDepoAccountId, - AccountError.RequiredFieldEmpty, - false, - depoAccountId -> { - Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); - Account account = accountImdg.getSingleObjectByID(depoAccountId); - if (account == null) return AccountError.AccountNotFound; - return null; - }), - DictionaryPresentRule.instance("status", - TradingClearingRegistryNewRequest::getStatus, - IMDGDistributedNames.Map_ServiceStatusDictionary, - ServiceStatusDictionary.class, - AccountError.RequiredFieldEmpty, - AccountError.WrongFieldValue, - false, - statusValue -> { - Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); - Long moneyAccountId = tradingClearingRegistryAutoNewRequest.getMoneyAccountId(); - Long depoAccountId = tradingClearingRegistryAutoNewRequest.getDepoAccountId(); - Account moneyAccount = accountImdg.getSingleObjectByID(moneyAccountId); - Account depoAccount = depoAccountId != null ? accountImdg.getSingleObjectByID(depoAccountId) : null; - if ( - (depoAccount != null && (ServiceStatus.Active.equalsByKey(depoAccount.getStatus()) || ServiceStatus.Reopened.equalsByKey(depoAccount.getStatus()))) && - (ServiceStatus.Active.equalsByKey(moneyAccount.getStatus()) || ServiceStatus.Reopened.equalsByKey(moneyAccount.getStatus())) - ) { - - } - - String statusCode = statusValue.getCode(); - if (WorkflowStatus.Active.equalsByKey(statusCode)) return null; - return AccountError.WrongFieldValue; - }) - ); - }; - } @Bean("tradingClearingRegistryNewRequest") public Function tradingClearingRegistryNewRequestValidator( @@ -104,7 +38,7 @@ public class TradingClearingRegistryValidationConfig { Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); addImdg.accept(IMDGDistributedNames.Map_Company); addImdg.accept(IMDGDistributedNames.Map_Account); - addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary); + addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary); return new ValidatorImpl<>(context, IdPresentRule.instance("companyId", TradingClearingRegistryNewRequest::getCompanyId, @@ -131,6 +65,8 @@ public class TradingClearingRegistryValidationConfig { if (account == null) return AccountError.AccountNotFound; return null; }), + // todo на будущее: нужна ли эта проверка, если при добавлении регистра статус заполняется автоматически + // на основе полей moneyAccountId и depoAccountId, то же касается TradingClearingRegistryNewRequest, нужно ли там поле status DictionaryPresentRule.instance("status", TradingClearingRegistryNewRequest::getStatus, IMDGDistributedNames.Map_ServiceStatusDictionary, @@ -155,7 +91,7 @@ public class TradingClearingRegistryValidationConfig { ImdgValidationContext context = new ImdgValidationContext<>(); context.setValidatedObject(tradingClearingRegistryUpdateRequest); Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); - addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary); + addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary); addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry); return new ValidatorImpl<>(context, IdPresentRule.instance("id", @@ -166,8 +102,8 @@ public class TradingClearingRegistryValidationConfig { AccountError.TradingClearingRegistryNotFound), DictionaryPresentRule.instance("status", TradingClearingRegistryUpdateRequest::getStatus, - IMDGDistributedNames.Map_WorkflowStatusDictionary, - WorkflowStatusDictionary.class, + IMDGDistributedNames.Map_ServiceStatusDictionary, + ServiceStatusDictionary.class, AccountError.RequiredFieldEmpty, AccountError.WrongFieldValue, false) diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java index cec060ea0..c4855b536 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -7,10 +7,12 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.account.ClearingAccount; import ru.clearing.classes.statics.data.account.DepoAccount; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.BaseRequest; import ru.spcex.clearing.platform.messaging.domain.Consts; @@ -19,15 +21,20 @@ import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingR import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest; 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.util.security.UserRoleVerification; import ru.spcex.clearing.validation.common.ValidationHelper; +import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose; -import ru.spcex.platform.enumeration.WorkflowStatus; 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.Arrays; +import java.util.List; import java.util.function.Function; @Service @@ -40,23 +47,27 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini private final Imdg tradingClearingRegistryImdg; private final Imdg depoAccountImdg; private final Imdg clearingAccountImdg; + private final Imdg accountImdg; private final Imdg companyImdg; private final Function tradingClearingRegistryUpdateRequestValidator; private final Function tradingClearingRegistryNewRequestValidator; private final Function tradingClearingRegistryBlockRequestValidator; + private final IMessageResolver messageResolver; + public TradingClearingRegistryService(Consumer kafkaQueue, Producer kafkaProducer, ImdgProvider imdgProvider, ValidationHelper validationHelper, UserRoleVerification userRoleVerification, + IMessageResolver messageResolver, @Qualifier("tradingClearingRegistryNewRequest") Function tradingClearingRegistryNewRequestValidator, @Qualifier("tradingClearingRegistryUpdateRequest") Function tradingClearingRegistryUpdateRequestValidator, @Qualifier("tradingClearingRegistryBlockRequest") - Function tradingClearingRegistryBlockRequestValidator) { + Function tradingClearingRegistryBlockRequestValidator) { super(kafkaQueue, kafkaProducer); this.validationHelper = validationHelper; this.userRoleVerification = userRoleVerification; @@ -67,16 +78,15 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class); this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); this.tradingClearingRegistryUpdateRequestValidator = tradingClearingRegistryUpdateRequestValidator; this.tradingClearingRegistryBlockRequestValidator = tradingClearingRegistryBlockRequestValidator; + this.messageResolver = messageResolver; } @Override public void afterPropertiesSet() throws Exception { init(); - callback(TradingClearingRegistryNewRequest.class) - .setConsumer(this::tradingClearingRegistryAutoNew) - .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, callbacks::put); callback(TradingClearingRegistryNewRequest.class) .setConsumer(this::tradingClearingRegistryNew) .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, callbacks::put); @@ -88,18 +98,8 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put); } - public RequestInfoUpdate tradingClearingRegistryAutoNew(BaseRequest userRequest) { - log.debug("TradingClearingRegistryAutoNewRequest received"); - - - - Long id = null; - log.debug("successfully processed, id {}", id); - return null; - } - public RequestInfoUpdate tradingClearingRegistryNew(BaseRequest userRequest) { - log.debug("TradingClearingRegistryNewRequest received"); + log.debug("TradingClearingRegistryAutoNewRequest received"); RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); if (requestInfoUpdate != null) return requestInfoUpdate; @@ -114,18 +114,46 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini tradingClearingRegistry.setCompanyId(req.getCompanyId()); tradingClearingRegistry.setMoneyAccountId(req.getMoneyAccountId()); tradingClearingRegistry.setDepoAaccountId(req.getDepoAccountId()); - tradingClearingRegistry.setStatus(WorkflowStatus.Active.getKey()); - // todo tradingClearingRegistryType из соответствующего параметра очереди но в запросе он не фигурирует - // пока оставил вычисление аналогичное автоматическому добавлению ТКР - String tradingRegistryType; - if (req.getDepoAccountId() != null) { - DepoAccount depoAccount = depoAccountImdg.getSingleObjectByID(req.getDepoAccountId()); - tradingRegistryType = depoAccount.getDepoAccountType(); + DepoAccount depoAccount = req.getDepoAccountId() != null ? depoAccountImdg.getSingleObjectByID(req.getDepoAccountId()) : null; + Account depoAccountMain = depoAccount != null ? accountImdg.getSingleObjectByID(depoAccount.getAccountId()) : null; + + ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); + Account clearingAccountMain = accountImdg.getSingleObjectByID(clearingAccount.getAccountId()); + + List activeStatuses = Arrays.asList(ServiceStatus.Active.getKey(), ServiceStatus.Reopened.getKey()); + String status = null; + if (depoAccountMain != null) { + if (activeStatuses.contains(depoAccountMain.getStatus()) && activeStatuses.contains(clearingAccountMain.getStatus())) + status = ServiceStatus.Active.getKey(); + if (depoAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey()) || clearingAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) + status = ServiceStatus.Blocked.getKey(); + if (depoAccountMain.getStatus().equals(ServiceStatus.Suspended.getKey()) || clearingAccountMain.getStatus().equals(ServiceStatus.Suspended.getKey())) + status = ServiceStatus.Suspended.getKey(); + if (depoAccountMain.getStatus().equals(ServiceStatus.Closed.getKey()) || clearingAccountMain.getStatus().equals(ServiceStatus.Closed.getKey())) + status = ServiceStatus.Closed.getKey(); } else { - ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); - tradingRegistryType = clearingAccount.getClearingAccountType(); + if (activeStatuses.contains(clearingAccountMain.getStatus())) + status = ServiceStatus.Active.getKey(); + if (clearingAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) + status = ServiceStatus.Blocked.getKey(); + if (clearingAccountMain.getStatus().equals(ServiceStatus.Suspended.getKey())) + status = ServiceStatus.Suspended.getKey(); + if (clearingAccountMain.getStatus().equals(ServiceStatus.Closed.getKey())) + status = ServiceStatus.Closed.getKey(); } + if (status == null) { + String errMsg = messageResolver.resolve(new EnumMessage(AccountError.WrongFieldValue, req.getMoneyAccountId())); + return new RequestInfoUpdate() + .setStatus(Status.Error) + .setMessage(errMsg) + .setId(userRequest.getId()); + } + tradingClearingRegistry.setStatus(status); + + String tradingRegistryType; + if (depoAccount != null) tradingRegistryType = depoAccount.getDepoAccountType(); + else tradingRegistryType = clearingAccount.getClearingAccountType(); tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType); TradingClearingRegistryPurpose registryPurpose; @@ -134,7 +162,8 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey()); Company company = companyImdg.getSingleObjectByID(req.getCompanyId()); - String code = company.getClearingCode() + registryPurpose.getKey() + registryPurpose; + String code = "%4s".formatted(company.getClearingCode()).replace(' ', '0'); + code += registryPurpose.getKey(); if (registryPurpose == TradingClearingRegistryPurpose.C) code += tradingRegistryType + id; else code += "AT" + id; tradingClearingRegistry.setCode(code); @@ -182,7 +211,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini CommonDeleteRequest req = userRequest.getRequestPayload(); TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId()); - tradingClearingRegistry.setStatus(WorkflowStatus.Blocked.getKey()); + tradingClearingRegistry.setStatus(ServiceStatus.Blocked.getKey()); tradingClearingRegistryImdg.update(tradingClearingRegistry); 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 d6b06bcf7..c250e2a6e 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 @@ -81,7 +81,6 @@ public interface Consts { String DESTINATION_CLIENT_CODE_UPDATE = "client-code-update"; String DESTINATION_CLIENT_CODE_DELETE = "client-code-delete"; - String DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW = "trading-clearing-registry-auto-new"; String DESTINATION_TRADING_CLEARING_REGISTRY_NEW = "trading-clearing-registry-new"; String DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE = "trading-clearing-registry-update"; String DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK = "trading-clearing-registry-block"; From 31950816619fb1cd6509733fad20e4b8f71ee283 Mon Sep 17 00:00:00 2001 From: akulikov Date: Fri, 5 May 2023 13:59:43 +0300 Subject: [PATCH 4/9] http://jira.mfd.msk:8088/browse/CLS-271 TradingClearingRegistryServiceTest --- .../validation/AccountValidationConfig.java | 8 +- .../BankAccountValidationConfig.java | 8 +- ...adingClearingRegistryValidationConfig.java | 29 +- .../config/validation/ValidationConfig.java | 8 +- .../account/service/AccountService.java | 12 +- .../account/service/BankAccountService.java | 14 +- .../TradingClearingRegistryService.java | 19 +- .../TradingClearingRegistryServiceTest.java | 261 ++++++++++++++++++ 8 files changed, 313 insertions(+), 46 deletions(-) create mode 100644 clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java index 8f9cd76eb..f1a5f0293 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java @@ -10,7 +10,7 @@ import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountUpdateRequest; -import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; import ru.spcex.clearing.validation.common.rules.FieldRequiredRule; import ru.spcex.clearing.validation.common.rules.IdPresentRule; @@ -153,17 +153,17 @@ public class AccountValidationConfig { } @Bean("correspondentAccountBlockRequestValidator") - public Function correspondentAccountBlockRequestValidator( + public Function correspondentAccountBlockRequestValidator( Map> imdgForValidation ) { return correspondentAccountBlockRequest -> { - ImdgValidationContext context = new ImdgValidationContext<>(); + ImdgValidationContext context = new ImdgValidationContext<>(); context.setValidatedObject(correspondentAccountBlockRequest); Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); addImdg.accept(IMDGDistributedNames.Map_Account); return new ValidatorImpl<>(context, IdPresentRule.instance("id", - CommonDeleteRequest::getId, + CommonIdRequest::getId, IMDGDistributedNames.Map_Account, Account.class, AccountError.RequiredFieldEmpty, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java index c4c350bb4..3c6b00d6e 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java @@ -10,7 +10,7 @@ import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountUpdateRequest; -import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; import ru.spcex.clearing.validation.common.rules.FieldRequiredRule; import ru.spcex.clearing.validation.common.rules.IdPresentRule; @@ -132,18 +132,18 @@ public class BankAccountValidationConfig { } @Bean("bankAccountBlockRequestValidator") - public Function bankAccountBlockRequestValidator( + public Function bankAccountBlockRequestValidator( Map> imdgForValidation ) { return bankAccountBlockRequest -> { - ImdgValidationContext context = new ImdgValidationContext<>(); + ImdgValidationContext context = new ImdgValidationContext<>(); context.setValidatedObject(bankAccountBlockRequest); Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); addImdg.accept(IMDGDistributedNames.Map_BankAccount); addImdg.accept(IMDGDistributedNames.Map_Account); return new ValidatorImpl<>(context, IdPresentRule.instance("id", - CommonDeleteRequest::getId, + CommonIdRequest::getId, IMDGDistributedNames.Map_BankAccount, BankAccount.class, AccountError.RequiredFieldEmpty, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java index b32ebb6e5..32fb2f34f 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java @@ -2,13 +2,14 @@ package ru.spcex.clearing.account.config.validation; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.account.ClearingAccount; +import ru.clearing.classes.statics.data.account.DepoAccount; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.platform.dictionary.ServiceStatusDictionary; import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; -import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest; import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; @@ -37,7 +38,8 @@ public class TradingClearingRegistryValidationConfig { context.setValidatedObject(tradingClearingRegistryNewRequest); Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); addImdg.accept(IMDGDistributedNames.Map_Company); - addImdg.accept(IMDGDistributedNames.Map_Account); + addImdg.accept(IMDGDistributedNames.Map_ClearingAccount); + addImdg.accept(IMDGDistributedNames.Map_DepoAccount); addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary); return new ValidatorImpl<>(context, IdPresentRule.instance("companyId", @@ -50,9 +52,11 @@ public class TradingClearingRegistryValidationConfig { TradingClearingRegistryNewRequest::getMoneyAccountId, AccountError.RequiredFieldEmpty, moneyAccountId -> { - Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); - Account account = accountImdg.getSingleObjectByID(moneyAccountId); - if (account == null) return AccountError.AccountNotFound; + Imdg clearingAccountImdg = context.obtainMap( + IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class + ); + ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(moneyAccountId); + if (clearingAccount == null) return AccountError.AccountNotFound; return null; }), FieldRequiredRule.instance("depoAccountId", @@ -60,9 +64,10 @@ public class TradingClearingRegistryValidationConfig { AccountError.RequiredFieldEmpty, false, depoAccountId -> { - Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); - Account account = accountImdg.getSingleObjectByID(depoAccountId); - if (account == null) return AccountError.AccountNotFound; + if (depoAccountId == null) return null; + Imdg depoAccountImdg = context.obtainMap(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class); + DepoAccount depoAccount = depoAccountImdg.getSingleObjectByID(depoAccountId); + if (depoAccount == null) return AccountError.AccountNotFound; return null; }), // todo на будущее: нужна ли эта проверка, если при добавлении регистра статус заполняется автоматически @@ -112,17 +117,17 @@ public class TradingClearingRegistryValidationConfig { } @Bean("tradingClearingRegistryBlockRequest") - public Function tradingClearingRegistryBlockRequestValidator( + public Function tradingClearingRegistryBlockRequestValidator( Map> imdgForValidation ) { return tradingClearingRegistryBlockRequest -> { - ImdgValidationContext context = new ImdgValidationContext<>(); + ImdgValidationContext context = new ImdgValidationContext<>(); context.setValidatedObject(tradingClearingRegistryBlockRequest); Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry); return new ValidatorImpl<>(context, IdPresentRule.instance("id", - CommonDeleteRequest::getId, + CommonIdRequest::getId, IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class, AccountError.RequiredFieldEmpty, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java index fd41493df..6fedb6269 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java @@ -3,12 +3,10 @@ package ru.spcex.clearing.account.config.validation; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import ru.clearing.classes.statics.data.account.Account; -import ru.clearing.classes.statics.data.account.BankAccount; -import ru.clearing.classes.statics.data.account.ClearingAccount; -import ru.clearing.classes.statics.data.account.InformationAccount; +import ru.clearing.classes.statics.data.account.*; import ru.clearing.classes.statics.data.company.ClearingMemberCategory; import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.platform.dictionary.AccountTypeDictionary; import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary; import ru.clearing.platform.dictionary.CurrencyCodeDictionary; @@ -41,7 +39,9 @@ public class ValidationConfig { addImdg.accept(IMDGDistributedNames.Map_BankAccount, BankAccount.class); addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary, CurrencyCodeDictionary.class); addImdg.accept(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); + addImdg.accept(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class); addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class); + addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class); return imdg; } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java index fdc36e84d..ff1aeb8b7 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java @@ -21,7 +21,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf0 import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart; import ru.spcex.clearing.platform.messaging.domain.cud.balance.AccountSdfToStatementRequestPart; import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest; -import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.platform.messaging.service.Status; @@ -57,7 +57,7 @@ public class AccountService extends QueueConsumer implements InitializingBean { private final ValidationHelper validationHelper; private final Function accountNewRequestValidator; private final Function accountUpdateRequestValidator; - private final Function accountBlockRequestValidator; + private final Function accountBlockRequestValidator; @Autowired public AccountService(Consumer kafkaQueue, @@ -72,7 +72,7 @@ public class AccountService extends QueueConsumer implements InitializingBean { @Qualifier("correspondentAccountUpdateRequestValidator") Function accountUpdateRequestValidator, @Qualifier("correspondentAccountBlockRequestValidator") - Function accountBlockRequestValidator) { + Function accountBlockRequestValidator) { super(kafkaQueue, kafkaProducer); this.accountMap = imdgProvider.getImdg( IMDGDistributedNames.Map_Account, Account.class @@ -103,7 +103,7 @@ public class AccountService extends QueueConsumer implements InitializingBean { callback(CorrespondentAccountUpdateRequest.class) .setConsumer(this::correspondentAccountUpdate) .forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_UPDATE, callbacks::put); - callback(CommonDeleteRequest.class) + callback(CommonIdRequest.class) .setConsumer(this::correspondentAccountBlock) .forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_BLOCK, callbacks::put); init(); @@ -161,7 +161,7 @@ public class AccountService extends QueueConsumer implements InitializingBean { return null; } - public RequestInfoUpdate correspondentAccountBlock(BaseRequest userRequest) { + public RequestInfoUpdate correspondentAccountBlock(BaseRequest userRequest) { log.debug("AccountBlockRequest received"); RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); @@ -170,7 +170,7 @@ public class AccountService extends QueueConsumer implements InitializingBean { requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, accountBlockRequestValidator); if (requestInfoUpdate != null) return requestInfoUpdate; - CommonDeleteRequest request = userRequest.getRequestPayload(); + CommonIdRequest request = userRequest.getRequestPayload(); Account account = accountMap.getSingleObjectByID(request.getId()); account.setStatus(ServiceStatus.Blocked.getKey()); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java index de0fb0be8..bff14701c 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java @@ -15,7 +15,7 @@ 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.BankAccountNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountUpdateRequest; -import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.util.security.UserRoleVerification; @@ -44,7 +44,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea private final Function bankAccountNewRequestValidator; private final Function bankAccountUpdateRequestValidator; - private final Function bankAccountBlockRequestValidator; + private final Function bankAccountBlockRequestValidator; @Autowired public BankAccountService(Consumer kafkaQueue, @@ -58,7 +58,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea @Qualifier("bankAccountUpdateRequestValidator") Function bankAccountUpdateRequestValidator, @Qualifier("bankAccountBlockRequestValidator") - Function bankAccountBlockRequestValidator) { + Function bankAccountBlockRequestValidator) { super(kafkaQueue, kafkaProducer); this.bankAccountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_BankAccount, BankAccount.class); this.accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); @@ -79,7 +79,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea callback(BankAccountUpdateRequest.class) .setFunction(this::bankAccountUpdate) .forDestination(Consts.DESTINATION_BANK_ACCOUNT_UPDATE, callbacks::put); - callback(CommonDeleteRequest.class) + callback(CommonIdRequest.class) .setFunction(this::bankAccountBlock) .forDestination(Consts.DESTINATION_BANK_ACCOUNT_BLOCK, callbacks::put); init(); @@ -194,8 +194,8 @@ public class BankAccountService extends QueueConsumer implements InitializingBea return null; } - private RequestInfoUpdate bankAccountBlock(BaseRequest userRequest) { - CommonDeleteRequest req = userRequest.getRequestPayload(); + private RequestInfoUpdate bankAccountBlock(BaseRequest userRequest) { + CommonIdRequest req = userRequest.getRequestPayload(); RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); if (requestInfoUpdate != null) return requestInfoUpdate; @@ -203,7 +203,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, bankAccountBlockRequestValidator); if (requestInfoUpdate != null) return requestInfoUpdate; - log.debug("CommonDeleteRequest received id = {}", req.getId()); + log.debug("CommonIdRequest received id = {}", req.getId()); BankAccount bankAccount = bankAccountMap.getSingleObjectByID(req.getId()); Account account = accountMap.getSingleObjectByID(bankAccount.getAccountId()); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java index c4855b536..aaafb6972 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -16,7 +16,7 @@ import ru.spcex.clearing.account.errors.AccountError; 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.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest; import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest; import ru.spcex.clearing.platform.messaging.service.QueueConsumer; @@ -52,7 +52,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini private final Function tradingClearingRegistryUpdateRequestValidator; private final Function tradingClearingRegistryNewRequestValidator; - private final Function tradingClearingRegistryBlockRequestValidator; + private final Function tradingClearingRegistryBlockRequestValidator; private final IMessageResolver messageResolver; @@ -67,7 +67,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini @Qualifier("tradingClearingRegistryUpdateRequest") Function tradingClearingRegistryUpdateRequestValidator, @Qualifier("tradingClearingRegistryBlockRequest") - Function tradingClearingRegistryBlockRequestValidator) { + Function tradingClearingRegistryBlockRequestValidator) { super(kafkaQueue, kafkaProducer); this.validationHelper = validationHelper; this.userRoleVerification = userRoleVerification; @@ -93,13 +93,13 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini callback(TradingClearingRegistryUpdateRequest.class) .setConsumer(this::tradingClearingRegistryUpdate) .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE, callbacks::put); - callback(CommonDeleteRequest.class) + callback(CommonIdRequest.class) .setConsumer(this::tradingClearingRegistryBlock) .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put); } public RequestInfoUpdate tradingClearingRegistryNew(BaseRequest userRequest) { - log.debug("TradingClearingRegistryAutoNewRequest received"); + log.debug("TradingClearingRegistryNewRequest received"); RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); if (requestInfoUpdate != null) return requestInfoUpdate; @@ -123,7 +123,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini List activeStatuses = Arrays.asList(ServiceStatus.Active.getKey(), ServiceStatus.Reopened.getKey()); String status = null; - if (depoAccountMain != null) { + if (depoAccountMain != null && depoAccountMain.getStatus() != null) { if (activeStatuses.contains(depoAccountMain.getStatus()) && activeStatuses.contains(clearingAccountMain.getStatus())) status = ServiceStatus.Active.getKey(); if (depoAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey()) || clearingAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) @@ -132,7 +132,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini status = ServiceStatus.Suspended.getKey(); if (depoAccountMain.getStatus().equals(ServiceStatus.Closed.getKey()) || clearingAccountMain.getStatus().equals(ServiceStatus.Closed.getKey())) status = ServiceStatus.Closed.getKey(); - } else { + } else if (clearingAccountMain.getStatus() != null) { if (activeStatuses.contains(clearingAccountMain.getStatus())) status = ServiceStatus.Active.getKey(); if (clearingAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) @@ -200,7 +200,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini return null; } - public RequestInfoUpdate tradingClearingRegistryBlock(BaseRequest userRequest) { + public RequestInfoUpdate tradingClearingRegistryBlock(BaseRequest userRequest) { log.debug("TradingClearingRegistryBlockRequest received"); RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); if (requestInfoUpdate != null) return requestInfoUpdate; @@ -208,10 +208,11 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryBlockRequestValidator); if (requestInfoUpdate != null) return requestInfoUpdate; - CommonDeleteRequest req = userRequest.getRequestPayload(); + CommonIdRequest req = userRequest.getRequestPayload(); TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId()); tradingClearingRegistry.setStatus(ServiceStatus.Blocked.getKey()); + tradingClearingRegistry.setUpdated(Instant.now()); tradingClearingRegistryImdg.update(tradingClearingRegistry); diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java new file mode 100644 index 000000000..7704cf73b --- /dev/null +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java @@ -0,0 +1,261 @@ +package ru.spcex.clearing.account.service; + +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.MockProducer; +import org.apache.kafka.clients.producer.ProducerRecord; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.boot.test.mock.mockito.SpyBean; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.account.ClearingAccount; +import ru.clearing.classes.statics.data.account.DepoAccount; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.clearing.platform.dictionary.ServiceStatusDictionary; +import ru.spcex.clearing.account.config.BeanConfiguration; +import ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration; +import ru.spcex.clearing.account.config.KafkaConfigTest; +import ru.spcex.clearing.account.config.validation.TradingClearingRegistryValidationConfig; +import ru.spcex.clearing.account.config.validation.ValidationConfig; +import ru.spcex.clearing.account.utils.MatcherFactory; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest; +import ru.spcex.platform.enumeration.ServiceStatus; +import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose; +import ru.spcex.platform.enumeration.WorkflowStatus; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; + +import javax.annotation.PostConstruct; + +import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator; +import static ru.spcex.clearing.account.utils.TestUtils.*; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + BeanConfiguration.class, + ValidationConfig.class, + TradingClearingRegistryValidationConfig.class, + TradingClearingRegistryService.class, + HazelcastServiceTestConfiguration.class, + KafkaConfigTest.class}) +class TradingClearingRegistryServiceTest { + public static final MatcherFactory.Matcher TRADING_CLEARING_REGISTRY_MATCHER = usingIgnoringFieldsComparator(); + private static final int PARTITION = 0; + private static final String TOPIC_ACCOUNT_NEW = Consts.ACCOUNT_NEW_SDF01; + private static final String account = "123456789123"; + private static final Long companyId = 0L; + private static final Long relationId = 0L; + @Autowired + TradingClearingRegistryService tradingClearingRegistryService; + @Autowired + @Qualifier("hazelcastServiceTest") + private HazelcastService hazelcastServiceTest; + + @Captor + private ArgumentCaptor producerRecord; + @SpyBean + private MockProducer producer; + + private Imdg tradingClearingRegistryImdg; + private Imdg companyImdg; + private Imdg serviceStatusDictionaryImdg; + + private Imdg clearingAccountImdg; + private Long clearingAccountId; + + private Imdg depoAccountImdg; + private Long depoAccountId; + + private Imdg accountImdg; + private Long accountId; + + static boolean oneNewRequestDone = false; + + @PostConstruct + private void init() { + hazelcastServiceTest.waitAvailable(); + tradingClearingRegistryImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class + ); + companyImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_Company, Company.class + ); + serviceStatusDictionaryImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class + ); + accountImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_Account, Account.class + ); + clearingAccountImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class + ); + depoAccountImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_DepoAccount, DepoAccount.class + ); + ServiceStatusDictionary serviceStatusDictionary = new ServiceStatusDictionary(); + serviceStatusDictionary.setCode(ServiceStatus.Active.getKey()); + serviceStatusDictionary.setName(ServiceStatus.Active.getKey()); + serviceStatusDictionaryImdg.insert(serviceStatusDictionary); + + Company company = new Company(); + company.setId(companyId); + company.setWorkflowStatus(WorkflowStatus.Active.getKey()); + company.setClearingCode("77"); + companyImdg.insert(company); + + Account account = new Account(); + account.setStatus(ServiceStatus.Active.getKey()); + accountId = accountImdg.insert(account); + + DepoAccount depoAccount = new DepoAccount(); + depoAccount.setAccountId(accountId); + depoAccount.setDepoAccountType("DAT"); + depoAccountId = depoAccountImdg.insert(depoAccount); + + ClearingAccount clearingAccount = new ClearingAccount(); + clearingAccount.setAccountId(accountId); + clearingAccount.setClearingAccountType("CAT"); + clearingAccountId = clearingAccountImdg.insert(clearingAccount); + } + + @Test + void tradingClearingRegistryNew_moneyAccount() { + TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest(); + tradingClearingRegistryNewRequest.setCompanyId(companyId); + tradingClearingRegistryNewRequest.setMoneyAccountId(clearingAccountId); + + TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry(); + predictableTradingClearingRegistry.setCompanyId(companyId); + predictableTradingClearingRegistry.setCode("0077MAT"); + predictableTradingClearingRegistry.setMoneyAccountId(clearingAccountId); + predictableTradingClearingRegistry.setTradingClearingRegistryType("CAT"); + predictableTradingClearingRegistry.setTradingClearingRegistryPurpose(TradingClearingRegistryPurpose.M.getKey()); + predictableTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey()); + + String jsonString = getJsonStringForNew(tradingClearingRegistryNewRequest, 0L); + + addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(), + Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, + PARTITION + (oneNewRequestDone ? 1 : 0), + 0, + jsonString); + + waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + + TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next(); + predictableTradingClearingRegistry.setId(resultNew.getId()); + predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId()); + predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated()); + predictableTradingClearingRegistry.setCreated(resultNew.getCreated()); + + TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry); + tradingClearingRegistryImdg.delete(resultNew); + + oneNewRequestDone = true; + } + + @Test + void tradingClearingRegistryNew_depoAccount() { + TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest(); + tradingClearingRegistryNewRequest.setCompanyId(companyId); + tradingClearingRegistryNewRequest.setMoneyAccountId(clearingAccountId); + tradingClearingRegistryNewRequest.setDepoAccountId(depoAccountId); + + TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry(); + predictableTradingClearingRegistry.setCompanyId(companyId); + predictableTradingClearingRegistry.setCode("0077CDAT"); + predictableTradingClearingRegistry.setMoneyAccountId(clearingAccountId); + predictableTradingClearingRegistry.setDepoAaccountId(depoAccountId); + predictableTradingClearingRegistry.setTradingClearingRegistryType("DAT"); + predictableTradingClearingRegistry.setTradingClearingRegistryPurpose(TradingClearingRegistryPurpose.C.getKey()); + predictableTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey()); + + String jsonString = getJsonStringForNew(tradingClearingRegistryNewRequest, 0L); + + addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(), + Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, + PARTITION + (oneNewRequestDone ? 1 : 0), + 0, + jsonString); + + waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + + TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next(); + predictableTradingClearingRegistry.setId(resultNew.getId()); + predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId()); + predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated()); + predictableTradingClearingRegistry.setCreated(resultNew.getCreated()); + + TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry); + tradingClearingRegistryImdg.delete(resultNew); + + oneNewRequestDone = true; + } + + @Test + void tradingClearingRegistryUpdate() { + TradingClearingRegistry existTradingClearingRegistry = new TradingClearingRegistry(); + existTradingClearingRegistry.setStatus(ServiceStatus.Closed.getKey()); + Long registryId = tradingClearingRegistryImdg.insert(existTradingClearingRegistry); + + TradingClearingRegistryUpdateRequest tradingClearingRegistryUpdateRequest = new TradingClearingRegistryUpdateRequest(); + tradingClearingRegistryUpdateRequest.setStatus(ServiceStatus.Active.getKey()); + tradingClearingRegistryUpdateRequest.setId(registryId); + + String jsonString = getJsonStringForUPDATE(tradingClearingRegistryUpdateRequest, 0); + + //ACT + addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(), + Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE, + PARTITION, + 0, + jsonString); + + //ASSERT + waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + + TradingClearingRegistry resultUpdating = tradingClearingRegistryImdg.getSingleObjectByID(registryId); + existTradingClearingRegistry.setUpdated(resultUpdating.getUpdated()); + existTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey()); + TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultUpdating, existTradingClearingRegistry); + tradingClearingRegistryImdg.delete(resultUpdating); + } + + @Test + void tradingClearingRegistryBlock() { + TradingClearingRegistry existTradingClearingRegistry = new TradingClearingRegistry(); + existTradingClearingRegistry.setStatus(ServiceStatus.Closed.getKey()); + Long registryId = tradingClearingRegistryImdg.insert(existTradingClearingRegistry); + + CommonDeleteRequest tradingClearingRegistryDeleteRequest = new CommonDeleteRequest(); + tradingClearingRegistryDeleteRequest.setId(registryId); + + String jsonString = getJsonStringForUPDATE(tradingClearingRegistryDeleteRequest, 0); + + //ACT + addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(), + Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, + PARTITION, + 0, + jsonString); + + //ASSERT + waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + + TradingClearingRegistry resultUpdating = tradingClearingRegistryImdg.getSingleObjectByID(registryId); + existTradingClearingRegistry.setUpdated(resultUpdating.getUpdated()); + existTradingClearingRegistry.setStatus(ServiceStatus.Blocked.getKey()); + TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultUpdating, existTradingClearingRegistry); + tradingClearingRegistryImdg.delete(resultUpdating); + } +} \ No newline at end of file From f5e2886ad63bc47372944c56143ea07c5d2b2e1f Mon Sep 17 00:00:00 2001 From: akulikov Date: Fri, 5 May 2023 15:13:43 +0300 Subject: [PATCH 5/9] http://jira.mfd.msk:8088/browse/CLS-271 TradingClearingRegistryService, fix for informationAccount --- ...adingClearingRegistryValidationConfig.java | 10 ++- .../TradingClearingRegistryService.java | 17 ++++- .../TradingClearingRegistryServiceTest.java | 65 +++++++++++++++++-- 3 files changed, 82 insertions(+), 10 deletions(-) diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java index 32fb2f34f..28d06ed70 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java @@ -4,6 +4,7 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import ru.clearing.classes.statics.data.account.ClearingAccount; import ru.clearing.classes.statics.data.account.DepoAccount; +import ru.clearing.classes.statics.data.account.InformationAccount; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.platform.dictionary.ServiceStatusDictionary; @@ -40,6 +41,7 @@ public class TradingClearingRegistryValidationConfig { addImdg.accept(IMDGDistributedNames.Map_Company); addImdg.accept(IMDGDistributedNames.Map_ClearingAccount); addImdg.accept(IMDGDistributedNames.Map_DepoAccount); + addImdg.accept(IMDGDistributedNames.Map_InformationAccount); addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary); return new ValidatorImpl<>(context, IdPresentRule.instance("companyId", @@ -56,7 +58,13 @@ public class TradingClearingRegistryValidationConfig { IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class ); ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(moneyAccountId); - if (clearingAccount == null) return AccountError.AccountNotFound; + if (clearingAccount == null) { + Imdg informationAccountImdg = context.obtainMap( + IMDGDistributedNames.Map_InformationAccount, InformationAccount.class + ); + InformationAccount infoAccount = informationAccountImdg.getSingleObjectByID(moneyAccountId); + if (infoAccount == null) return AccountError.AccountNotFound; + } return null; }), FieldRequiredRule.instance("depoAccountId", diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java index aaafb6972..9b092effa 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -10,6 +10,7 @@ import org.springframework.stereotype.Service; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.account.ClearingAccount; import ru.clearing.classes.statics.data.account.DepoAccount; +import ru.clearing.classes.statics.data.account.InformationAccount; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.spcex.clearing.account.errors.AccountError; @@ -26,6 +27,7 @@ import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose; +import ru.spcex.platform.enumeration.TradingClearingRegistryType; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.utils.enumeration.EnumMessage; @@ -47,6 +49,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini private final Imdg tradingClearingRegistryImdg; private final Imdg depoAccountImdg; private final Imdg clearingAccountImdg; + private final Imdg informationAccountImdg; private final Imdg accountImdg; private final Imdg companyImdg; @@ -77,6 +80,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini ); this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class); this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); + this.informationAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class); this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); this.tradingClearingRegistryUpdateRequestValidator = tradingClearingRegistryUpdateRequestValidator; @@ -118,8 +122,11 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini DepoAccount depoAccount = req.getDepoAccountId() != null ? depoAccountImdg.getSingleObjectByID(req.getDepoAccountId()) : null; Account depoAccountMain = depoAccount != null ? accountImdg.getSingleObjectByID(depoAccount.getAccountId()) : null; + InformationAccount infoAccount = null; ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); - Account clearingAccountMain = accountImdg.getSingleObjectByID(clearingAccount.getAccountId()); + if (clearingAccount == null) infoAccount = informationAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); + Long clearingAccountId = clearingAccount != null ? clearingAccount.getAccountId() : infoAccount.getAccountId(); + Account clearingAccountMain = accountImdg.getSingleObjectByID(clearingAccountId); List activeStatuses = Arrays.asList(ServiceStatus.Active.getKey(), ServiceStatus.Reopened.getKey()); String status = null; @@ -152,8 +159,12 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini tradingClearingRegistry.setStatus(status); String tradingRegistryType; - if (depoAccount != null) tradingRegistryType = depoAccount.getDepoAccountType(); - else tradingRegistryType = clearingAccount.getClearingAccountType(); + if (depoAccount != null) { + tradingRegistryType = depoAccount.getDepoAccountType(); + } else { + if (clearingAccount != null) tradingRegistryType = clearingAccount.getClearingAccountType(); + else tradingRegistryType = TradingClearingRegistryType.Owner_A.getKey(); + } tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType); TradingClearingRegistryPurpose registryPurpose; diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java index 7704cf73b..4ac339059 100644 --- a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java @@ -15,6 +15,7 @@ import org.springframework.test.context.junit.jupiter.SpringExtension; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.account.ClearingAccount; import ru.clearing.classes.statics.data.account.DepoAccount; +import ru.clearing.classes.statics.data.account.InformationAccount; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.platform.dictionary.ServiceStatusDictionary; @@ -31,6 +32,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingR import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest; import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose; +import ru.spcex.platform.enumeration.TradingClearingRegistryType; import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; @@ -76,10 +78,15 @@ class TradingClearingRegistryServiceTest { private Imdg depoAccountImdg; private Long depoAccountId; + private Imdg informationAccountImdg; + private Long infoAccountId; + private Imdg accountImdg; private Long accountId; - static boolean oneNewRequestDone = false; + private Long account2Id; + + static int newRequestCnt = 0; @PostConstruct private void init() { @@ -102,6 +109,9 @@ class TradingClearingRegistryServiceTest { depoAccountImdg = hazelcastServiceTest.getImdg( IMDGDistributedNames.Map_DepoAccount, DepoAccount.class ); + informationAccountImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_InformationAccount, InformationAccount.class + ); ServiceStatusDictionary serviceStatusDictionary = new ServiceStatusDictionary(); serviceStatusDictionary.setCode(ServiceStatus.Active.getKey()); serviceStatusDictionary.setName(ServiceStatus.Active.getKey()); @@ -117,6 +127,8 @@ class TradingClearingRegistryServiceTest { account.setStatus(ServiceStatus.Active.getKey()); accountId = accountImdg.insert(account); + account2Id = accountImdg.insert(account); + DepoAccount depoAccount = new DepoAccount(); depoAccount.setAccountId(accountId); depoAccount.setDepoAccountType("DAT"); @@ -126,10 +138,14 @@ class TradingClearingRegistryServiceTest { clearingAccount.setAccountId(accountId); clearingAccount.setClearingAccountType("CAT"); clearingAccountId = clearingAccountImdg.insert(clearingAccount); + + InformationAccount informationAccount = new InformationAccount(); + informationAccount.setAccountId(account2Id); + infoAccountId = informationAccountImdg.insert(informationAccount); } @Test - void tradingClearingRegistryNew_moneyAccount() { + void tradingClearingRegistryNew_moneyAccount_clearingAccount() { TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest(); tradingClearingRegistryNewRequest.setCompanyId(companyId); tradingClearingRegistryNewRequest.setMoneyAccountId(clearingAccountId); @@ -146,7 +162,7 @@ class TradingClearingRegistryServiceTest { addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(), Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, - PARTITION + (oneNewRequestDone ? 1 : 0), + newRequestCnt, 0, jsonString); @@ -161,9 +177,46 @@ class TradingClearingRegistryServiceTest { TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry); tradingClearingRegistryImdg.delete(resultNew); - oneNewRequestDone = true; + newRequestCnt++; } + @Test + void tradingClearingRegistryNew_moneyAccount_informationAccount() { + TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest(); + tradingClearingRegistryNewRequest.setCompanyId(companyId); + tradingClearingRegistryNewRequest.setMoneyAccountId(infoAccountId); + + TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry(); + predictableTradingClearingRegistry.setCompanyId(companyId); + predictableTradingClearingRegistry.setCode("0077MAT"); + predictableTradingClearingRegistry.setMoneyAccountId(infoAccountId); + predictableTradingClearingRegistry.setTradingClearingRegistryType(TradingClearingRegistryType.Owner_A.getKey()); + predictableTradingClearingRegistry.setTradingClearingRegistryPurpose(TradingClearingRegistryPurpose.M.getKey()); + predictableTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey()); + + String jsonString = getJsonStringForNew(tradingClearingRegistryNewRequest, 0L); + + addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(), + Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, + newRequestCnt, + 0, + jsonString); + + waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + + TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next(); + predictableTradingClearingRegistry.setId(resultNew.getId()); + predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId()); + predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated()); + predictableTradingClearingRegistry.setCreated(resultNew.getCreated()); + + TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry); + tradingClearingRegistryImdg.delete(resultNew); + + newRequestCnt++; + } + + @Test void tradingClearingRegistryNew_depoAccount() { TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest(); @@ -184,7 +237,7 @@ class TradingClearingRegistryServiceTest { addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(), Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, - PARTITION + (oneNewRequestDone ? 1 : 0), + newRequestCnt, 0, jsonString); @@ -199,7 +252,7 @@ class TradingClearingRegistryServiceTest { TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry); tradingClearingRegistryImdg.delete(resultNew); - oneNewRequestDone = true; + newRequestCnt++; } @Test From 654943ec3652e8b611eea20bc2c7f38702c6da69 Mon Sep 17 00:00:00 2001 From: akulikov Date: Fri, 5 May 2023 18:19:32 +0300 Subject: [PATCH 6/9] http://jira.mfd.msk:8088/browse/CLS-271 --- .../clearing/account/errors/AccountError.java | 3 + .../TradingClearingRegistryService.java | 185 ++++++++++++++++-- 2 files changed, 176 insertions(+), 12 deletions(-) diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java index 7a4b12852..dda968b42 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java @@ -12,6 +12,9 @@ public enum AccountError implements IErrorEnumId { CompanyNotFound(5013L), CompanyNotActive(5014L), InfoAccountAlreadyExist(5015L), + TradingClearingRegistryAlreadyExist(5016L), + DepoAccountNotFound(5017L), + MoneyAccountNotFound(5018L), ClearingCategoryNotFound(5019L), TradingClearingRegistryNotFound(5022L), ; diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java index 9b092effa..2bfd55cf3 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -12,6 +12,7 @@ import ru.clearing.classes.statics.data.account.ClearingAccount; import ru.clearing.classes.statics.data.account.DepoAccount; import ru.clearing.classes.statics.data.account.InformationAccount; import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.company.relation.Relation; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; @@ -25,18 +26,23 @@ import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.platform.messaging.service.Status; import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.validation.common.ValidationHelper; +import ru.spcex.platform.enumeration.AccountType; import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose; import ru.spcex.platform.enumeration.TradingClearingRegistryType; 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.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.enumeration.IMessageResolver; import ru.spcex.platform.utils.validation.IValidator; import java.time.Instant; import java.util.Arrays; +import java.util.Collection; import java.util.List; +import java.util.Map; import java.util.function.Function; @Service @@ -52,6 +58,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini private final Imdg informationAccountImdg; private final Imdg accountImdg; private final Imdg companyImdg; + private final Imdg relationImdg; private final Function tradingClearingRegistryUpdateRequestValidator; private final Function tradingClearingRegistryNewRequestValidator; @@ -83,6 +90,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini this.informationAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class); this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); + this.relationImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Relation, Relation.class); this.tradingClearingRegistryUpdateRequestValidator = tradingClearingRegistryUpdateRequestValidator; this.tradingClearingRegistryBlockRequestValidator = tradingClearingRegistryBlockRequestValidator; this.messageResolver = messageResolver; @@ -102,7 +110,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put); } - public RequestInfoUpdate tradingClearingRegistryNew(BaseRequest userRequest) { + public RequestInfoUpdate tradingClearingRegistryAutoNew(BaseRequest userRequest) { log.debug("TradingClearingRegistryNewRequest received"); RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); if (requestInfoUpdate != null) return requestInfoUpdate; @@ -125,28 +133,128 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini InformationAccount infoAccount = null; ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); if (clearingAccount == null) infoAccount = informationAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); - Long clearingAccountId = clearingAccount != null ? clearingAccount.getAccountId() : infoAccount.getAccountId(); - Account clearingAccountMain = accountImdg.getSingleObjectByID(clearingAccountId); + Long accountId = clearingAccount != null ? clearingAccount.getAccountId() : infoAccount.getAccountId(); + Account accountMain = accountImdg.getSingleObjectByID(accountId); + + + // TODO: WELCOME TO HELL + // Проверка выглядит очень сложно и запутанно, потому что репортеры сами не до конца понимают, какая она должна быть. + // Пока что она соответствует ТЗ, но возможно будет правиться, поэтому расписана без выноса кода в методы и + // прочих методов сокращения кода + Relation relation = relationImdg.getSingleObjectByFieldValues(Map.of("consumerId", req.getCompanyId())); + if (ru.spcex.platform.enumeration.Service.MKR.equalsByKey(relation.getService())) { + TradingClearingRegistry registry = tradingClearingRegistryImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId())); + if (registry != null) { + String errMsg = messageResolver.resolve( + new EnumMessage(AccountError.TradingClearingRegistryAlreadyExist, + req.getCompanyId(), + registry.getId()) + ); + return new RequestInfoUpdate() + .setMessage(errMsg) + .setStatus(Status.Error) + .setId(userRequest.getId()); + } + DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId())); + if (depoAccountForCheck == null) { + String errMsg = messageResolver.resolve(new EnumMessage(AccountError.DepoAccountNotFound, req.getCompanyId())); + return new RequestInfoUpdate() + .setMessage(errMsg) + .setStatus(Status.Error) + .setId(userRequest.getId()); + } + } else if (ru.spcex.platform.enumeration.Service.FOND.equalsByKey(relation.getService())) { + if (AccountType.Info.equalsByKey(accountMain.getStatus())) { + TradingClearingRegistry registry = tradingClearingRegistryImdg.getSingleObjectByFieldValues(Map.of( + "companyId", req.getCompanyId(), + "tradingClearingRegistryType", TradingClearingRegistryPurpose.M.getKey() + )); + if (registry != null) { + String errMsg = messageResolver.resolve( + new EnumMessage(AccountError.TradingClearingRegistryAlreadyExist, + req.getCompanyId(), + registry.getId()) + ); + return new RequestInfoUpdate() + .setMessage(errMsg) + .setStatus(Status.Error) + .setId(userRequest.getId()); + } + DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId())); + if (depoAccountForCheck == null) { + String errMsg = messageResolver.resolve(new EnumMessage(AccountError.DepoAccountNotFound, req.getCompanyId())); + return new RequestInfoUpdate() + .setMessage(errMsg) + .setStatus(Status.Error) + .setId(userRequest.getId()); + } + } else if (AccountType.Clrn.equalsByKey(accountMain.getStatus())) { + ImdgPredicateBuilder imdgPredicateBuilder = tradingClearingRegistryImdg.predicateBuilder(); + ImdgPredicate predicate = imdgPredicateBuilder.and( + imdgPredicateBuilder.equals("companyId", req.getCompanyId()), + imdgPredicateBuilder.or( + imdgPredicateBuilder.equals("tradingClearingRegistryPurpose", TradingClearingRegistryPurpose.M.getKey()), + imdgPredicateBuilder.equals("tradingClearingRegistryPurpose", TradingClearingRegistryPurpose.C.getKey()) + ) + ); + Collection registry = tradingClearingRegistryImdg.getCollectionObjectsByPredicate(predicate); + if (!registry.isEmpty()) { + String errMsg = messageResolver.resolve( + new EnumMessage(AccountError.TradingClearingRegistryAlreadyExist, + req.getCompanyId(), + registry.iterator().next().getId()) + ); + return new RequestInfoUpdate() + .setMessage(errMsg) + .setStatus(Status.Error) + .setId(userRequest.getId()); + } + DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId())); + if (depoAccountForCheck == null) { + String errMsg = messageResolver.resolve(new EnumMessage(AccountError.DepoAccountNotFound, req.getCompanyId())); + return new RequestInfoUpdate() + .setMessage(errMsg) + .setStatus(Status.Error) + .setId(userRequest.getId()); + } + } else if (AccountType.Depo.equalsByKey(accountMain.getStatus())) { + InformationAccount infoAccountForCheck = informationAccountImdg.getSingleObjectByFieldValues( + Map.of("companyId", req.getCompanyId()) + ); + ClearingAccount clearingAccountForCheck = clearingAccountImdg.getSingleObjectByFieldValues( + Map.of("companyId", req.getCompanyId()) + ); + if (infoAccountForCheck == null && clearingAccountForCheck == null) { + String errMsg = messageResolver.resolve( + new EnumMessage(AccountError.MoneyAccountNotFound, req.getCompanyId()) + ); + return new RequestInfoUpdate() + .setMessage(errMsg) + .setStatus(Status.Error) + .setId(userRequest.getId()); + } + } + } List activeStatuses = Arrays.asList(ServiceStatus.Active.getKey(), ServiceStatus.Reopened.getKey()); String status = null; if (depoAccountMain != null && depoAccountMain.getStatus() != null) { - if (activeStatuses.contains(depoAccountMain.getStatus()) && activeStatuses.contains(clearingAccountMain.getStatus())) + if (activeStatuses.contains(depoAccountMain.getStatus()) && activeStatuses.contains(accountMain.getStatus())) status = ServiceStatus.Active.getKey(); - if (depoAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey()) || clearingAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) + if (depoAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey()) || accountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) status = ServiceStatus.Blocked.getKey(); - if (depoAccountMain.getStatus().equals(ServiceStatus.Suspended.getKey()) || clearingAccountMain.getStatus().equals(ServiceStatus.Suspended.getKey())) + if (depoAccountMain.getStatus().equals(ServiceStatus.Suspended.getKey()) || accountMain.getStatus().equals(ServiceStatus.Suspended.getKey())) status = ServiceStatus.Suspended.getKey(); - if (depoAccountMain.getStatus().equals(ServiceStatus.Closed.getKey()) || clearingAccountMain.getStatus().equals(ServiceStatus.Closed.getKey())) + if (depoAccountMain.getStatus().equals(ServiceStatus.Closed.getKey()) || accountMain.getStatus().equals(ServiceStatus.Closed.getKey())) status = ServiceStatus.Closed.getKey(); - } else if (clearingAccountMain.getStatus() != null) { - if (activeStatuses.contains(clearingAccountMain.getStatus())) + } else if (accountMain.getStatus() != null) { + if (activeStatuses.contains(accountMain.getStatus())) status = ServiceStatus.Active.getKey(); - if (clearingAccountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) + if (accountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) status = ServiceStatus.Blocked.getKey(); - if (clearingAccountMain.getStatus().equals(ServiceStatus.Suspended.getKey())) + if (accountMain.getStatus().equals(ServiceStatus.Suspended.getKey())) status = ServiceStatus.Suspended.getKey(); - if (clearingAccountMain.getStatus().equals(ServiceStatus.Closed.getKey())) + if (accountMain.getStatus().equals(ServiceStatus.Closed.getKey())) status = ServiceStatus.Closed.getKey(); } if (status == null) { @@ -189,6 +297,59 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini return null; } + public RequestInfoUpdate tradingClearingRegistryNew(BaseRequest userRequest) { + log.debug("TradingClearingRegistryNewRequest received"); + RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); + if (requestInfoUpdate != null) return requestInfoUpdate; + + requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryNewRequestValidator); + if (requestInfoUpdate != null) return requestInfoUpdate; + + TradingClearingRegistryNewRequest req = userRequest.getRequestPayload(); + + Long id = tradingClearingRegistryImdg.nextIDSequenceFor(); + TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry(); + tradingClearingRegistry.setId(id); + tradingClearingRegistry.setCompanyId(req.getCompanyId()); + tradingClearingRegistry.setMoneyAccountId(req.getMoneyAccountId()); + tradingClearingRegistry.setDepoAaccountId(req.getDepoAccountId()); + + DepoAccount depoAccount = req.getDepoAccountId() != null ? depoAccountImdg.getSingleObjectByID(req.getDepoAccountId()) : null; + ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); + + tradingClearingRegistry.setStatus(ServiceStatus.Active.getKey()); + + String tradingRegistryType; + if (depoAccount != null) { + tradingRegistryType = depoAccount.getDepoAccountType(); + } else { + if (clearingAccount != null) tradingRegistryType = clearingAccount.getClearingAccountType(); + else tradingRegistryType = TradingClearingRegistryType.Owner_A.getKey(); + } + tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType); + + TradingClearingRegistryPurpose registryPurpose; + if (req.getDepoAccountId() != null) registryPurpose = TradingClearingRegistryPurpose.C; + else registryPurpose = TradingClearingRegistryPurpose.M; + tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey()); + + Company company = companyImdg.getSingleObjectByID(req.getCompanyId()); + String code = "%4s".formatted(company.getClearingCode()).replace(' ', '0'); + code += registryPurpose.getKey(); + if (registryPurpose == TradingClearingRegistryPurpose.C) code += tradingRegistryType + id; + else code += "AT" + id; + tradingClearingRegistry.setCode(code); + + Instant now = Instant.now(); + tradingClearingRegistry.setCreated(now); + tradingClearingRegistry.setUpdated(now); + + tradingClearingRegistryImdg.insert(tradingClearingRegistry); + + log.debug("successfully processed, id {}", id); + return null; + } + public RequestInfoUpdate tradingClearingRegistryUpdate(BaseRequest userRequest) { log.debug("TradingClearingRegistryUpdateRequest received"); RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); From 65c235c01c3f4941d0c0febde0b5e4b6f3c50c16 Mon Sep 17 00:00:00 2001 From: akulikov Date: Fri, 5 May 2023 18:28:32 +0300 Subject: [PATCH 7/9] http://jira.mfd.msk:8088/browse/CLS-265 auto request for TCR new --- .../account/service/ClearingAccountService.java | 12 +++++++++++- .../clearing/account/service/DepoAccountService.java | 12 +++++++++++- .../account/service/InformationAccountService.java | 12 +++++++++++- .../service/TradingClearingRegistryService.java | 6 +++++- .../clearing/platform/messaging/domain/Consts.java | 1 + 5 files changed, 39 insertions(+), 4 deletions(-) diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java index a4ceddaa6..8b6779baf 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java @@ -16,9 +16,11 @@ 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.ClearingAccountNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.account.ClearingAccountUpdateRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest; 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.platform.messaging.service.sender.KafkaSender; import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.platform.enumeration.AccountType; import ru.spcex.platform.enumeration.ServiceStatus; @@ -38,6 +40,7 @@ import java.util.function.Function; @Service public class ClearingAccountService extends QueueConsumer implements InitializingBean { private final Logger log = LoggerFactory.getLogger(getClass()); + private final KafkaSender kafkaSender; private final AccountService accountService; private final ValidationHelper validationHelper; private final ImdgProvider imdgProvider; @@ -50,6 +53,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin @Autowired public ClearingAccountService(Consumer kafkaQueue, Producer kafkaResponseQueue, + KafkaSender kafkaSender, AccountService accountService, ValidationHelper validationHelper, ImdgProvider imdgProvider, @@ -59,6 +63,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin @Qualifier("clearingAccountUpdateRequestValidator") Function clearingAccountUpdateRequestValidator) { super(kafkaQueue, kafkaResponseQueue); + this.kafkaSender = kafkaSender; this.accountService = accountService; this.validationHelper = validationHelper; this.imdgProvider = imdgProvider; @@ -104,10 +109,11 @@ public class ClearingAccountService extends QueueConsumer implements Initializin ImdgTransaction imdgTransaction = imdgProvider.newTransaction(); boolean txOk = false; imdgTransaction.beginTransaction(); + ClearingAccount clearingAccount = null; try { accountId = accountImdg.insert(account); - ClearingAccount clearingAccount = new ClearingAccount(); + clearingAccount = new ClearingAccount(); clearingAccount.setCompanyId(req.getCompanyId()); clearingAccount.setAccountId(accountId); clearingAccount.setClearingAccountType(req.getClearingAccountType()); @@ -116,6 +122,10 @@ public class ClearingAccountService extends QueueConsumer implements Initializin } finally { if (txOk) { imdgTransaction.commitTransaction(); + TradingClearingRegistryNewRequest request = new TradingClearingRegistryNewRequest(); + request.setMoneyAccountId(accountId); + request.setCompanyId(clearingAccount.getCompanyId()); + kafkaSender.sendRequestToQueue(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, request); log.debug("successfully processed, new clearing account id {}, account id {}", clearingAccountId, accountId); } else { // todo выяснить, что возвращать из метода в этой ситуации diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java index 719820108..f8199ba29 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java @@ -13,8 +13,10 @@ 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.DepoAccountNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest; 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.validation.common.ValidationHelper; import ru.spcex.platform.enumeration.AccountType; import ru.spcex.platform.enumeration.ServiceStatus; @@ -30,6 +32,7 @@ import java.util.function.Function; public class DepoAccountService extends QueueConsumer implements InitializingBean { private final Logger log = LoggerFactory.getLogger(getClass()); + private final KafkaSender kafkaSender; private final ValidationHelper validationHelper; private final ImdgProvider imdgProvider; private final AccountService accountService; @@ -39,12 +42,14 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea public DepoAccountService(Consumer kafkaQueue, Producer kafkaProducer, + KafkaSender kafkaSender, ValidationHelper validationHelper, ImdgProvider imdgProvider, AccountService accountService, @Qualifier("depoAccountNewRequestValidator") Function depoAccountNewRequestValidator) { super(kafkaQueue, kafkaProducer); + this.kafkaSender = kafkaSender; this.validationHelper = validationHelper; this.imdgProvider = imdgProvider; this.accountService = accountService; @@ -86,10 +91,11 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea ImdgTransaction imdgTransaction = imdgProvider.newTransaction(); boolean txOk = false; imdgTransaction.beginTransaction(); + DepoAccount depoAccount = null; try { accountId = accountImdg.insert(account); - DepoAccount depoAccount = new DepoAccount(); + depoAccount = new DepoAccount(); depoAccount.setCompanyId(req.getCompanyId()); depoAccount.setAccountId(accountId); depoAccount.setDepoAccountType(req.getDepoAccountType()); @@ -98,6 +104,10 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea } finally { if (txOk) { imdgTransaction.commitTransaction(); + TradingClearingRegistryNewRequest request = new TradingClearingRegistryNewRequest(); + request.setDepoAccountId(accountId); + request.setCompanyId(depoAccount.getCompanyId()); + kafkaSender.sendRequestToQueue(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, request); log.debug("successfully processed, new depo account id {}, account id {}", depoAccountId, accountId); } else { // todo выяснить, что возвращать из метода в этой ситуации diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java index 5bb94636b..4b96243ae 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java @@ -15,9 +15,11 @@ 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.InformationAccountNewRequest; +import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest; 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.platform.messaging.service.sender.KafkaSender; import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.platform.enumeration.AccountType; import ru.spcex.platform.enumeration.ServiceStatus; @@ -37,6 +39,7 @@ import java.util.function.Function; @Service public class InformationAccountService extends QueueConsumer implements InitializingBean { private final Logger log = LoggerFactory.getLogger(getClass()); + private final KafkaSender kafkaSender; private final IMessageResolver messageResolver; private final ImdgProvider imdgProvider; private final ValidationHelper validationHelper; @@ -48,6 +51,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali @Autowired public InformationAccountService(Consumer kafkaQueue, Producer kafkaResponseQueue, + KafkaSender kafkaSender, IMessageResolver messageResolver, ImdgProvider imdgProvider, ValidationHelper validationHelper, @@ -55,6 +59,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali @Qualifier("informationAccountNewRequestValidator") Function infoAccountNewRequestValidator) { super(kafkaQueue, kafkaResponseQueue); + this.kafkaSender = kafkaSender; this.messageResolver = messageResolver; this.imdgProvider = imdgProvider; this.validationHelper = validationHelper; @@ -117,10 +122,11 @@ public class InformationAccountService extends QueueConsumer implements Initiali boolean txOk = false; Long informationAccountId = -1L; Long accountId = -1L; + InformationAccount informationAccount = null; try { accountId = accountImdg.insert(account); - InformationAccount informationAccount = new InformationAccount(); + informationAccount = new InformationAccount(); informationAccount.setId(newId); informationAccount.setAccountId(accountId); informationAccount.setClearingAccountId(anltAccount.getId()); @@ -130,6 +136,10 @@ public class InformationAccountService extends QueueConsumer implements Initiali } finally { if (txOk) { imdgTransaction.commitTransaction(); + TradingClearingRegistryNewRequest request = new TradingClearingRegistryNewRequest(); + request.setMoneyAccountId(informationAccountId); + request.setCompanyId(informationAccount.getCompanyId()); + kafkaSender.sendRequestToQueue(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, request); log.debug("successfully processed, new information account id {}, new account id {}", informationAccountId, accountId); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java index 2bfd55cf3..5d03d16a6 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -99,6 +99,9 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini @Override public void afterPropertiesSet() throws Exception { init(); + callback(TradingClearingRegistryNewRequest.class) + .setConsumer(this::tradingClearingRegistryAutoNew) + .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, callbacks::put); callback(TradingClearingRegistryNewRequest.class) .setConsumer(this::tradingClearingRegistryNew) .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, callbacks::put); @@ -140,7 +143,8 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini // TODO: WELCOME TO HELL // Проверка выглядит очень сложно и запутанно, потому что репортеры сами не до конца понимают, какая она должна быть. // Пока что она соответствует ТЗ, но возможно будет правиться, поэтому расписана без выноса кода в методы и - // прочих методов сокращения кода + // прочих методов сокращения кода. В дальнейшем, после тестирования и окончательного выяснения вида проверки, + // её стоит вынести на этап валидации запроса. Relation relation = relationImdg.getSingleObjectByFieldValues(Map.of("consumerId", req.getCompanyId())); if (ru.spcex.platform.enumeration.Service.MKR.equalsByKey(relation.getService())) { TradingClearingRegistry registry = tradingClearingRegistryImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId())); 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 c250e2a6e..bdc985908 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 @@ -82,6 +82,7 @@ public interface Consts { String DESTINATION_CLIENT_CODE_DELETE = "client-code-delete"; String DESTINATION_TRADING_CLEARING_REGISTRY_NEW = "trading-clearing-registry-new"; + String DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW = "trading-clearing-registry-auto-new"; String DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE = "trading-clearing-registry-update"; String DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK = "trading-clearing-registry-block"; From 8d893d74cab3f81b685ca18b03bfd077b5b98002 Mon Sep 17 00:00:00 2001 From: akulikov Date: Fri, 5 May 2023 18:36:14 +0300 Subject: [PATCH 8/9] http://jira.mfd.msk:8088/browse/CLS-265 auto request for TCR new --- .../account/service/TradingClearingRegistryServiceTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java index 4ac339059..8dfb3495e 100644 --- a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java @@ -293,7 +293,7 @@ class TradingClearingRegistryServiceTest { CommonDeleteRequest tradingClearingRegistryDeleteRequest = new CommonDeleteRequest(); tradingClearingRegistryDeleteRequest.setId(registryId); - String jsonString = getJsonStringForUPDATE(tradingClearingRegistryDeleteRequest, 0); + String jsonString = getJsonStringForDELETE(tradingClearingRegistryDeleteRequest, 0); //ACT addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(), From 70e73b68aebc537845c2174eefa6cedfe00fad1f Mon Sep 17 00:00:00 2001 From: akulikov Date: Wed, 10 May 2023 13:23:38 +0300 Subject: [PATCH 9/9] fix after review --- .../account/config/validation/AccountValidationConfig.java | 2 +- .../validation/TradingClearingRegistryValidationConfig.java | 2 -- .../ru/spcex/clearing/account/service/BankAccountService.java | 1 - .../spcex/clearing/account/service/ClearingAccountService.java | 1 - .../ru/spcex/clearing/account/service/DepoAccountService.java | 1 - .../clearing/account/service/InformationAccountService.java | 1 - .../account/service/TradingClearingRegistryService.java | 3 ++- 7 files changed, 3 insertions(+), 8 deletions(-) diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java index f1a5f0293..ef68fd75a 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java @@ -140,7 +140,7 @@ public class AccountValidationConfig { AccountError.WrongFieldValue), DictionaryPresentRule.instance("accountType", CorrespondentAccountUpdateRequest::getAccountType, - IMDGDistributedNames.Map_ServiceStatusDictionary, + IMDGDistributedNames.Map_AccountTypeDictionary, ServiceStatusDictionary.class, AccountError.RequiredFieldEmpty, AccountError.WrongFieldValue, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java index 28d06ed70..f936a6925 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java @@ -78,8 +78,6 @@ public class TradingClearingRegistryValidationConfig { if (depoAccount == null) return AccountError.AccountNotFound; return null; }), - // todo на будущее: нужна ли эта проверка, если при добавлении регистра статус заполняется автоматически - // на основе полей moneyAccountId и depoAccountId, то же касается TradingClearingRegistryNewRequest, нужно ли там поле status DictionaryPresentRule.instance("status", TradingClearingRegistryNewRequest::getStatus, IMDGDistributedNames.Map_ServiceStatusDictionary, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java index bff14701c..1069939db 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/BankAccountService.java @@ -224,7 +224,6 @@ public class BankAccountService extends QueueConsumer implements InitializingBea bankAccount.getId(), account.getId()); } else { - // todo выяснить, что возвращать из метода в этой ситуации log.debug("failed block, bank account id {}, new account id {}", bankAccount.getId(), account.getId()); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java index 8b6779baf..766b1f890 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java @@ -128,7 +128,6 @@ public class ClearingAccountService extends QueueConsumer implements Initializin kafkaSender.sendRequestToQueue(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, request); log.debug("successfully processed, new clearing account id {}, account id {}", clearingAccountId, accountId); } else { - // todo выяснить, что возвращать из метода в этой ситуации log.debug("failed insert, new clearing account id {}, new account id {} (if id = -1 then insert is failed)", clearingAccountId, accountId); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java index f8199ba29..5495595c2 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/DepoAccountService.java @@ -110,7 +110,6 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea kafkaSender.sendRequestToQueue(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, request); log.debug("successfully processed, new depo account id {}, account id {}", depoAccountId, accountId); } else { - // todo выяснить, что возвращать из метода в этой ситуации log.debug("failed insert, new depo account id {}, new account id {} (if id = -1 then insert is failed)", depoAccountId, accountId); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java index 4b96243ae..175c058c4 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/InformationAccountService.java @@ -144,7 +144,6 @@ public class InformationAccountService extends QueueConsumer implements Initiali informationAccountId, accountId); } else { - // todo выяснить, что возвращать из метода в этой ситуации log.debug("failed insert, new information account id {}, new account id {} (if id = -1 then insert is failed)", informationAccountId, accountId); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java index 5d03d16a6..0b3c43303 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -140,7 +140,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini Account accountMain = accountImdg.getSingleObjectByID(accountId); - // TODO: WELCOME TO HELL + // TODO // Проверка выглядит очень сложно и запутанно, потому что репортеры сами не до конца понимают, какая она должна быть. // Пока что она соответствует ТЗ, но возможно будет правиться, поэтому расписана без выноса кода в методы и // прочих методов сокращения кода. В дальнейшем, после тестирования и окончательного выяснения вида проверки, @@ -154,6 +154,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini req.getCompanyId(), registry.getId()) ); + log.error("process failed: {}", errMsg); return new RequestInfoUpdate() .setMessage(errMsg) .setStatus(Status.Error)