diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/BeanConfiguration.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/BeanConfiguration.java index c219ed4c1..05af1c9d3 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/BeanConfiguration.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/BeanConfiguration.java @@ -6,10 +6,11 @@ import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Scope; import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.util.security.UserRoleVerification; +import ru.spcex.clearing.util.services.IMDGMessageResolver; +import ru.spcex.clearing.util.services.RequestHelper; import ru.spcex.platform.enumeration.UserRole; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.utils.enumeration.IMessageResolver; -import ru.spcex.clearing.util.services.IMDGMessageResolver; @Configuration public class BeanConfiguration { @@ -18,6 +19,12 @@ public class BeanConfiguration { return new IMDGMessageResolver(imdgProvider); } + @Bean + @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public RequestHelper requestHelper(IMessageResolver messageResolver) { + return new RequestHelper(messageResolver, AccountError.GeneralError); + } + @Bean @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) public UserRoleVerification userRoleVerification(ImdgProvider imdgProvider, IMessageResolver messageResolver) { 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..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 @@ -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.platform.messaging.domain.cud.common.CommonIdRequest; 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, + ServiceStatusDictionary.class, AccountError.RequiredFieldEmpty, AccountError.WrongFieldValue, accountType -> { @@ -148,23 +153,23 @@ 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, 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..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,13 +10,14 @@ 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; 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, @@ -131,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/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 new file mode 100644 index 000000000..f936a6925 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java @@ -0,0 +1,144 @@ +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.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; +import ru.spcex.clearing.account.errors.AccountError; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +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; +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.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_ClearingAccount); + addImdg.accept(IMDGDistributedNames.Map_DepoAccount); + addImdg.accept(IMDGDistributedNames.Map_InformationAccount); + addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary); + 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 clearingAccountImdg = context.obtainMap( + IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class + ); + ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(moneyAccountId); + 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", + TradingClearingRegistryNewRequest::getDepoAccountId, + AccountError.RequiredFieldEmpty, + false, + depoAccountId -> { + 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; + }), + DictionaryPresentRule.instance("status", + TradingClearingRegistryNewRequest::getStatus, + IMDGDistributedNames.Map_ServiceStatusDictionary, + ServiceStatusDictionary.class, + AccountError.RequiredFieldEmpty, + AccountError.WrongFieldValue, + false, + statusValue -> { + String statusCode = statusValue.getCode(); + if (ServiceStatus.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_ServiceStatusDictionary); + 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_ServiceStatusDictionary, + ServiceStatusDictionary.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", + CommonIdRequest::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 d6189008f..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,15 +3,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.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; +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; @@ -40,6 +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/errors/AccountError.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java index 82789613d..f3c8f8362 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 @@ -3,6 +3,7 @@ package ru.spcex.clearing.account.errors; import ru.spcex.platform.utils.enumeration.IErrorEnumId; public enum AccountError implements IErrorEnumId { + GeneralError(5000L), UserVerifyDenial(5001L), RequiredFieldEmpty(5002L), WrongFieldValue(5004L), @@ -12,7 +13,11 @@ public enum AccountError implements IErrorEnumId { CompanyNotFound(5013L), CompanyNotActive(5014L), InfoAccountAlreadyExist(5015L), - ClearingCategoryNotFound(5019L) + TradingClearingRegistryAlreadyExist(5016L), + DepoAccountNotFound(5017L), + MoneyAccountNotFound(5018L), + ClearingCategoryNotFound(5019L), + TradingClearingRegistryNotFound(5022L), ; private final Long id; 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..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,15 +21,15 @@ 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; 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; @@ -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,10 +170,10 @@ 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(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..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 @@ -15,13 +15,13 @@ 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; 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; @@ -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(); @@ -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); @@ -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,11 +203,11 @@ 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()); - account.setStatus(AccountStatus.BLOCKED.getKey()); + account.setStatus(ServiceStatus.Blocked.getKey()); account.setUpdated(Instant.now()); ImdgTransaction imdgTransaction = imdgProvider.newTransaction(); @@ -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 03f148353..c17f62e64 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,18 +16,19 @@ 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.util.services.RequestHelper; 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; 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; @@ -38,33 +39,39 @@ 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; private final Imdg accountImdg; private final Imdg clearingAccountImdg; private final IMessageResolver messageResolver; + private final RequestHelper requestHelper; private final Function clearingAccountNewRequestValidator; private final Function clearingAccountUpdateRequestValidator; @Autowired public ClearingAccountService(Consumer kafkaQueue, Producer kafkaResponseQueue, + KafkaSender kafkaSender, AccountService accountService, ValidationHelper validationHelper, ImdgProvider imdgProvider, IMessageResolver messageResolver, + RequestHelper requestHelper, @Qualifier("clearingAccountNewRequestValidator") Function clearingAccountNewRequestValidator, @Qualifier("clearingAccountUpdateRequestValidator") Function clearingAccountUpdateRequestValidator) { super(kafkaQueue, kafkaResponseQueue); + this.kafkaSender = kafkaSender; this.accountService = accountService; this.validationHelper = validationHelper; this.imdgProvider = imdgProvider; this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); this.messageResolver = messageResolver; + this.requestHelper = requestHelper; this.clearingAccountNewRequestValidator = clearingAccountNewRequestValidator; this.clearingAccountUpdateRequestValidator = clearingAccountUpdateRequestValidator; } @@ -92,7 +99,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); @@ -104,10 +111,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,9 +124,12 @@ 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 выяснить, что возвращать из метода в этой ситуации log.debug("failed insert, new clearing account id {}, new account id {} (if id = -1 then insert is failed)", clearingAccountId, accountId); @@ -137,7 +148,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, @@ -147,18 +158,13 @@ public class ClearingAccountService extends QueueConsumer implements Initializin Long accountId = account.getId(); ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByFieldValues(Map.of("accountId", accountId)); - if (clearingAccount == null) { - String errMsg = messageResolver.resolve(new EnumMessage(AccountError.AccountNotFound, account.getAccount())); - return new RequestInfoUpdate() - .setId(userRequest.getId()) - .setStatus(Status.Error) - .setMessage(errMsg); - } + if (clearingAccount == null) + return requestHelper.makeErrorResponse(userRequest, AccountError.AccountNotFound, account.getAccount()); 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..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 @@ -13,11 +13,13 @@ 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.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; @@ -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; @@ -74,7 +79,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); @@ -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,9 +104,12 @@ 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 выяснить, что возвращать из метода в этой ситуации 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 2c74b2086..2de5a7513 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,18 +15,19 @@ 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.util.services.RequestHelper; 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; 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; @@ -37,10 +38,12 @@ 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; private final AccountService accountService; + private final RequestHelper requestHelper; private final Function infoAccountNewRequestValidator; private final Imdg informationAccountImdg; private final Imdg accountImdg; @@ -48,17 +51,21 @@ public class InformationAccountService extends QueueConsumer implements Initiali @Autowired public InformationAccountService(Consumer kafkaQueue, Producer kafkaResponseQueue, + KafkaSender kafkaSender, IMessageResolver messageResolver, ImdgProvider imdgProvider, ValidationHelper validationHelper, AccountService accountService, + RequestHelper requestHelper, @Qualifier("informationAccountNewRequestValidator") Function infoAccountNewRequestValidator) { super(kafkaQueue, kafkaResponseQueue); + this.kafkaSender = kafkaSender; this.messageResolver = messageResolver; this.imdgProvider = imdgProvider; this.validationHelper = validationHelper; this.accountService = accountService; + this.requestHelper = requestHelper; this.infoAccountNewRequestValidator = infoAccountNewRequestValidator; this.informationAccountImdg = imdgProvider.getImdg( IMDGDistributedNames.Map_InformationAccount, InformationAccount.class @@ -91,11 +98,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali ImdgPredicate andPredicate = accountPredicateBuilder.and(companyIdPredicate, accountTypePredicate); Collection accountsAnlt = accountImdg.getCollectionObjectsByPredicate(andPredicate); if (accountsAnlt.isEmpty()) { - String errMsg = messageResolver.resolve(new EnumMessage(AccountError.WrongFieldValue, "clearingAccountId")); - return new RequestInfoUpdate() - .setId(userRequest.getId()) - .setStatus(Status.Error) - .setMessage(errMsg); + return requestHelper.makeErrorResponse(userRequest, AccountError.WrongFieldValue, "clearingAccountId"); } else if (accountsAnlt.size() > 1) { log.warn("Account for companyId 1 and accountType=ANLT contains multiply elements, use first"); } @@ -105,7 +108,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); @@ -117,10 +120,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,11 +134,14 @@ 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); } 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 new file mode 100644 index 000000000..479db94a1 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java @@ -0,0 +1,359 @@ +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.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.company.relation.Relation; +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; +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; +import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; +import ru.spcex.clearing.util.security.UserRoleVerification; +import ru.spcex.clearing.util.services.RequestHelper; +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.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 +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 informationAccountImdg; + private final Imdg accountImdg; + private final Imdg companyImdg; + private final Imdg relationImdg; + + private final Function tradingClearingRegistryUpdateRequestValidator; + private final RequestHelper requestHelper; + 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, + RequestHelper requestHelper, + @Qualifier("tradingClearingRegistryNewRequest") + Function tradingClearingRegistryNewRequestValidator, + @Qualifier("tradingClearingRegistryUpdateRequest") + Function tradingClearingRegistryUpdateRequestValidator, + @Qualifier("tradingClearingRegistryBlockRequest") + Function tradingClearingRegistryBlockRequestValidator) { + super(kafkaQueue, kafkaProducer); + this.validationHelper = validationHelper; + this.userRoleVerification = userRoleVerification; + this.requestHelper = requestHelper; + 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.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; + } + + @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); + callback(TradingClearingRegistryUpdateRequest.class) + .setConsumer(this::tradingClearingRegistryUpdate) + .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE, callbacks::put); + callback(CommonIdRequest.class) + .setConsumer(this::tradingClearingRegistryBlock) + .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put); + } + + public RequestInfoUpdate tradingClearingRegistryAutoNew(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; + Account depoAccountMain = depoAccount != null ? accountImdg.getSingleObjectByID(depoAccount.getAccountId()) : null; + + InformationAccount infoAccount = null; + ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); + if (clearingAccount == null) infoAccount = informationAccountImdg.getSingleObjectByID(req.getMoneyAccountId()); + Long accountId = clearingAccount != null ? clearingAccount.getAccountId() : infoAccount.getAccountId(); + Account accountMain = accountImdg.getSingleObjectByID(accountId); + + + // TODO + // Проверка выглядит очень сложно и запутанно, потому что репортеры сами не до конца понимают, какая она должна быть. + // Пока что она соответствует ТЗ, но возможно будет правиться, поэтому расписана без выноса кода в методы и + // прочих методов сокращения кода. В дальнейшем, после тестирования и окончательного выяснения вида проверки, + // её стоит вынести на этап валидации запроса. + 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) { + return requestHelper.makeErrorResponse(userRequest, + AccountError.TradingClearingRegistryAlreadyExist, + req.getCompanyId(), + registry.getId()); + } + DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId())); + if (depoAccountForCheck == null) + return requestHelper.makeErrorResponse(userRequest, AccountError.DepoAccountNotFound, req.getCompanyId()); + } 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) { + return requestHelper.makeErrorResponse(userRequest, + AccountError.TradingClearingRegistryAlreadyExist, + req.getCompanyId(), + registry.getId()); + } + DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId())); + if (depoAccountForCheck == null) + return requestHelper.makeErrorResponse(userRequest, AccountError.DepoAccountNotFound, req.getCompanyId()); + } 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()) { + return requestHelper.makeErrorResponse(userRequest, + AccountError.TradingClearingRegistryAlreadyExist, + req.getCompanyId(), + registry.iterator().next().getId()); + } + DepoAccount depoAccountForCheck = depoAccountImdg.getSingleObjectByFieldValues(Map.of("companyId", req.getCompanyId())); + if (depoAccountForCheck == null) { + return requestHelper.makeErrorResponse(userRequest, AccountError.DepoAccountNotFound, req.getCompanyId()); + } + } 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) + return requestHelper.makeErrorResponse(userRequest, AccountError.MoneyAccountNotFound, req.getCompanyId()); + } + } + + 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(accountMain.getStatus())) + status = ServiceStatus.Active.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()) || accountMain.getStatus().equals(ServiceStatus.Suspended.getKey())) + status = ServiceStatus.Suspended.getKey(); + if (depoAccountMain.getStatus().equals(ServiceStatus.Closed.getKey()) || accountMain.getStatus().equals(ServiceStatus.Closed.getKey())) + status = ServiceStatus.Closed.getKey(); + } else if (accountMain.getStatus() != null) { + if (activeStatuses.contains(accountMain.getStatus())) + status = ServiceStatus.Active.getKey(); + if (accountMain.getStatus().equals(ServiceStatus.Blocked.getKey())) + status = ServiceStatus.Blocked.getKey(); + if (accountMain.getStatus().equals(ServiceStatus.Suspended.getKey())) + status = ServiceStatus.Suspended.getKey(); + if (accountMain.getStatus().equals(ServiceStatus.Closed.getKey())) + status = ServiceStatus.Closed.getKey(); + } + if (status == null) + return requestHelper.makeErrorResponse(userRequest, AccountError.WrongFieldValue, req.getMoneyAccountId()); + tradingClearingRegistry.setStatus(status); + + 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 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); + 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; + + CommonIdRequest req = userRequest.getRequestPayload(); + TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId()); + + tradingClearingRegistry.setStatus(ServiceStatus.Blocked.getKey()); + tradingClearingRegistry.setUpdated(Instant.now()); + + tradingClearingRegistryImdg.update(tradingClearingRegistry); + + log.debug("successfully processed, id {}", tradingClearingRegistry.getId()); + return null; + } +} 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..6644c2c85 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 @@ -37,6 +37,8 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; import javax.annotation.PostConstruct; import java.util.Map; +import static org.mockito.Mockito.timeout; +import static org.mockito.Mockito.verify; import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator; import static ru.spcex.clearing.account.utils.TestUtils.*; @@ -151,12 +153,13 @@ class ClearingAccountServiceTest { 0, jsonString); - waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + verify(producer, timeout(30_000L).times(2)) + .send(producerRecord.capture()); 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 +185,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 +196,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..52276ea0c 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 @@ -36,8 +36,11 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; import javax.annotation.PostConstruct; import java.util.Map; +import static org.mockito.Mockito.timeout; +import static org.mockito.Mockito.verify; import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator; -import static ru.spcex.clearing.account.utils.TestUtils.*; +import static ru.spcex.clearing.account.utils.TestUtils.addRecordToKafka; +import static ru.spcex.clearing.account.utils.TestUtils.getJsonStringForNew; @ExtendWith(SpringExtension.class) @ContextConfiguration(classes = { @@ -150,12 +153,13 @@ class DepoAccountServiceTest { 0, jsonString); - waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + verify(producer, timeout(30_000L).times(2)) + .send(producerRecord.capture()); 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..d03708acc 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 @@ -35,8 +35,11 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; import javax.annotation.PostConstruct; import java.util.Map; +import static org.mockito.Mockito.timeout; +import static org.mockito.Mockito.verify; import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator; -import static ru.spcex.clearing.account.utils.TestUtils.*; +import static ru.spcex.clearing.account.utils.TestUtils.addRecordToKafka; +import static ru.spcex.clearing.account.utils.TestUtils.getJsonStringForNew; @ExtendWith(SpringExtension.class) @ContextConfiguration(classes = { @@ -140,11 +143,13 @@ class InformationAccountServiceTest { 0, jsonString); - waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + //waiting for kafka producer send message (finale event) + verify(producer, timeout(30_000L).times(2)) + .send(producerRecord.capture()); 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/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..8dfb3495e --- /dev/null +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java @@ -0,0 +1,314 @@ +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.account.InformationAccount; +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.TradingClearingRegistryType; +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 informationAccountImdg; + private Long infoAccountId; + + private Imdg accountImdg; + private Long accountId; + + private Long account2Id; + + static int newRequestCnt = 0; + + @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 + ); + informationAccountImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_InformationAccount, InformationAccount.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); + + account2Id = 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); + + InformationAccount informationAccount = new InformationAccount(); + informationAccount.setAccountId(account2Id); + infoAccountId = informationAccountImdg.insert(informationAccount); + } + + @Test + void tradingClearingRegistryNew_moneyAccount_clearingAccount() { + 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, + 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_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(); + 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, + 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 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 = getJsonStringForDELETE(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 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 2d0f0cae6..05abd71ff 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 @@ -85,9 +85,10 @@ 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_DELETE = "trading-clearing-registry-delete"; // String DESTINATION_TRADING_CLEARING_REGISTRY_REPLY = "trading-clearing-registry"; + 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";