diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClientCodeValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClientCodeValidationConfig.java index 9a7dd0630..1b795ee56 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClientCodeValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClientCodeValidationConfig.java @@ -182,4 +182,27 @@ public class ClientCodeValidationConfig { }; } + @Bean("tkrEksAccountsGatewayValidator") + public Function newTkrEksAccountsGatewayValidator(Map> imdgForValidation) { + return tkrGatewayRequest -> { + ImdgValidationContext context = new ImdgValidationContext<>(); + context.setValidatedObject(tkrGatewayRequest); + Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_Company); + addImdg.accept(IMDGDistributedNames.Map_CompanySymbols); + addImdg.accept(IMDGDistributedNames.Map_Account); + addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry); + addImdg.accept(IMDGDistributedNames.Map_AccountSymbols); + addImdg.accept(IMDGDistributedNames.Map_DepoAccount); + return new ValidatorImpl<>(context, + FieldRequiredRule.instance("client_code", TkrAccount::getClientCode, AccountError.RequiredFieldEmpty), + GatewayClientCodeValidationRule.CompanyPresent, +// GatewayClientCodeValidationRule.AllAccountsPresent, + GatewayClientCodeValidationRule.DepoAccountsPresent +// GatewayClientCodeValidationRule.TcrIsNotPresent, +// GatewayClientCodeValidationRule.TcrListIsNotPresent + ); + }; + } + } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/AccountFacade.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/AccountFacade.java new file mode 100644 index 000000000..7db125408 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/AccountFacade.java @@ -0,0 +1,125 @@ +package ru.spcex.clearing.account.service.v2.facade; + +import java.time.Instant; +import java.util.Collection; +import java.util.Map; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Service; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.account.InformationAccount; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.misc.Currency; +import ru.spcex.clearing.account.service.AccountHelper; +import ru.spcex.clearing.account.service.InformationAccountService; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccount; +import ru.spcex.clearing.platform.messaging.domain.cud.gateway.MoneyAccountMsgRequest; +import ru.spcex.platform.classes.base.interfaces.IClearingFacade; +import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.CurrencyCode; +import ru.spcex.platform.enumeration.Sender; +import ru.spcex.platform.enumeration.WorkflowStatus; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgId; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; + +@Service +public class AccountFacade implements IClearingFacade { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final ImdgId idGenerator; + private final ImdgProvider imdgProvider; + private final Imdg accountImdg; + private final Imdg informationAccountImdg; + private final Imdg currencyImdg; + private final InformationAccountService informationAccountService; + private final AccountHelper accountHelper; + private final TradingClearingRegistryFacade tradingClearingRegistryFacade; + private final TradingClearingRegistryListFacade tradingClearingRegistryListFacade; + + public AccountFacade(ImdgProvider imdgProvider, + InformationAccountService informationAccountService, + AccountHelper accountHelper, + TradingClearingRegistryFacade tradingClearingRegistryFacade, + TradingClearingRegistryListFacade tradingClearingRegistryListFacade) { + this.idGenerator = imdgProvider.getImdgIdGenerator(); + this.imdgProvider = imdgProvider; + this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); + this.informationAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class); + this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class); + this.informationAccountService = informationAccountService; + this.accountHelper = accountHelper; + this.tradingClearingRegistryFacade = tradingClearingRegistryFacade; + this.tradingClearingRegistryListFacade = tradingClearingRegistryListFacade; + } + + public void createInfoAccount(TkrAccount account, Company company) { + for (MoneyAccountMsgRequest moneyAccountMsgRequest : account.getMoneyAccounts()) { + String currencyCode = moneyAccountMsgRequest.getCurrCode() == null ? CurrencyCode.RUB.getKey() : moneyAccountMsgRequest.getCurrCode(); + ImdgPredicateBuilder predicateBuilder = currencyImdg.predicateBuilder(); + Currency currency = currencyImdg.getFirstObjectByPredicate( + predicateBuilder.equals("currencyCode", currencyCode) + ); + + Long currencyCodeId = CurrencyCode.RUB.getKey().equals(currencyCode) ? 810 : currency.getId(); + Instant now = Instant.now(); + Account infoAccount = new Account(); + infoAccount.setCompanyId(company.getId()); + infoAccount.setAccount(moneyAccountMsgRequest.getEks_account()); + + ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); + ImdgPredicate andPredicate = pb.and( + pb.equals("accountType", AccountType.Anlt.getKey()), + pb.equals("currency", currency.getCurrencyCode()) + ); + Collection accountsAnlt = accountImdg.getCollectionObjectsByPredicate(andPredicate); + if (accountsAnlt.isEmpty()) { + log.warn("Account with {} not exist.", andPredicate); + } else if (accountsAnlt.size() > 1) { + log.warn("Account for companyId 1 and accountType=ANLT contains multiply elements, use first"); + } + Account anltAccount = accountsAnlt.iterator().next(); + String specialAnltAccId = anltAccount.getAccount().substring(anltAccount.getAccount().length() - 4); + Long infoSequenceId = informationAccountService.accountNextId(currencyCode, currencyCodeId); + String accountValue = informationAccountService.generateInfoAccount(currencyCodeId, infoSequenceId, specialAnltAccId); + log.trace("New info-account SequenceId={} account={}", infoSequenceId, accountValue); + infoAccount.setAccount(accountValue); + infoAccount.setAccountType(AccountType.Info.getKey()); + infoAccount.setCurrency(currencyCode); + infoAccount.setStatus(WorkflowStatus.Active.getKey()); + infoAccount.setCreated(now); + infoAccount.setUpdated(now); + accountHelper.fillAccountFromRelation(infoAccount, null, false); + + InformationAccount infoAcc = new InformationAccount(); + infoAcc.setAccountId(infoAccount.getId()); + Account firstAccountAntl = accountImdg.getFirstObjectByFieldValues(Map.of( + "companyId", Sender.One.getId(), + "accountType", AccountType.Anlt.getKey(), + "currency", infoAccount.getCurrency() + )); + if (firstAccountAntl == null) { + log.warn("Can not find 1 ANTL {} account for fill information ClearingAccountId.", infoAccount.getCurrency()); + } else { + infoAcc.setClearingAccountId(firstAccountAntl.getId()); + } + infoAcc.setCompanyId(infoAccount.getCompanyId()); + accountImdg.insert(infoAccount); + Long infoId = informationAccountImdg.insert(infoAcc); + log.debug("For account id={} make InformationAccount id={}", infoAccount.getId(), infoId); + + } + } + + public void lock() { +// tradingClearingRegistryFacade.lock() +// tradingClearingRegistryListFacade.lock() + } + + public void unlock() { +// tradingClearingRegistryFacade.lock() +// tradingClearingRegistryListFacade.lock() + } +} diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/ClientCodeFacade.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/ClientCodeFacade.java index a0b7cd4ca..7dd2b2fb0 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/ClientCodeFacade.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/ClientCodeFacade.java @@ -67,8 +67,8 @@ public class ClientCodeFacade implements IClearingFacade { clientCode.setCompanyId(request.getCompanyId()); clientCode.setCode(request.getCode()); - clientCode.setMoneyAccountId(request.getMoneyAccountId()); - clientCode.setDepoAccountId(request.getDepoAccountId()); +// clientCode.setMoneyAccountId(request.getMoneyAccountId()); +// clientCode.setDepoAccountId(request.getDepoAccountId()); clientCode.setStatus(request.getStatus()); clientCodeImdg.insert(clientCode); log.debug("successfully processed, new clientCode id {}", clientCode.getId()); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/listeners/ClientCodeMessageListener.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/listeners/ClientCodeMessageListener.java index a2d20ec51..044847770 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/listeners/ClientCodeMessageListener.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/listeners/ClientCodeMessageListener.java @@ -4,6 +4,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.concurrent.atomic.AtomicBoolean; import org.apache.kafka.clients.consumer.Consumer; import org.apache.kafka.clients.producer.Producer; import org.slf4j.Logger; @@ -15,6 +16,7 @@ import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.spcex.clearing.account.model.ValidationResult; import ru.spcex.clearing.account.service.v2.GatewayRequestCreator; +import ru.spcex.clearing.account.service.v2.facade.AccountFacade; import ru.spcex.clearing.account.service.v2.facade.ClientCodeFacade; import ru.spcex.clearing.account.service.v2.validators.ClientCodeValidator; import ru.spcex.clearing.account.validation.ClientCodeStoreObjects; @@ -46,6 +48,7 @@ public class ClientCodeMessageListener extends QueueConsumer implements Initiali private final ClientCodeValidator clientCodeValidator; private final GatewayRequestCreator gatewayRequestCreator; private final UserRoleVerification userRoleVerification; + private final AccountFacade accountFacade; public ClientCodeMessageListener(Consumer kafkaQueue, Producer kafkaProducer, @@ -54,7 +57,8 @@ public class ClientCodeMessageListener extends QueueConsumer implements Initiali ClientCodeFacade clientCodeFacade, ClientCodeValidator clientCodeValidator, GatewayRequestCreator gatewayRequestCreator, - UserRoleVerification userRoleVerification) { + UserRoleVerification userRoleVerification, + AccountFacade accountFacade) { super(kafkaQueue, kafkaProducer); this.kafkaSender = kafkaSender; this.imdgProvider = imdgProvider; @@ -62,6 +66,7 @@ public class ClientCodeMessageListener extends QueueConsumer implements Initiali this.clientCodeValidator = clientCodeValidator; this.gatewayRequestCreator = gatewayRequestCreator; this.userRoleVerification = userRoleVerification; + this.accountFacade = accountFacade; } @Override @@ -90,17 +95,39 @@ public class ClientCodeMessageListener extends QueueConsumer implements Initiali SendTkrRequest sendTkrRequest = new SendTkrRequest(); sendTkrRequest.setRequestId(gatewayRequest.getRequestId()); - boolean isAnyoneInvalid = false; + AtomicBoolean isAnyoneInvalid = new AtomicBoolean(false); + Map eksAccountsAfterValidation = new HashMap<>(); Map accountsAfterValidation = new HashMap<>(); - for (TkrAccount tkrAccount : gatewayRequest.getAccounts()) { + List withAccount = gatewayRequest.getAccounts().stream() + .filter(tkrAccount -> tkrAccount.getMoneyAccounts() != null && + tkrAccount.getMoneyAccounts().stream() + .anyMatch(moneyAccountMsgRequest -> moneyAccountMsgRequest.getAccount() != null)) + .toList(); + List withEksAccount = gatewayRequest.getAccounts().stream() + .filter(tkrAccount -> tkrAccount.getMoneyAccounts() != null && + tkrAccount.getMoneyAccounts().stream() + .anyMatch(moneyAccountMsgRequest -> moneyAccountMsgRequest.getEks_account() != null)) + .toList(); + + withAccount.forEach(tkrAccount -> { ValidationResult validationResult = clientCodeValidator.checkGatewayRequest(tkrAccount); if (!validationResult.isValid()) { log.debug("Validation failed for tkr.client_code {}", tkrAccount.getClientCode()); - isAnyoneInvalid = true; + isAnyoneInvalid.set(true); } accountsAfterValidation.put(tkrAccount, validationResult); - } - if (isAnyoneInvalid) { + }); + + withEksAccount.forEach(tkrAccount -> { + ValidationResult validationResult = clientCodeValidator.checkGatewayRequestWithEksAcc(tkrAccount); + if (!validationResult.isValid()) { + log.debug("Validation failed for tkr.client_code {}", tkrAccount.getClientCode()); + isAnyoneInvalid.set(true); + } + eksAccountsAfterValidation.put(tkrAccount, validationResult); + }); + + if (isAnyoneInvalid.get()) { log.debug("Create error request to gateway service"); List tkrs = accountsAfterValidation.entrySet() @@ -111,12 +138,30 @@ public class ClientCodeMessageListener extends QueueConsumer implements Initiali tkrAccountValidationResultEntry.getValue().errorMsg() )) .toList(); - sendTkrRequest.setTkrs(tkrs); + List eksTkrs = eksAccountsAfterValidation.entrySet() + .stream() + .map(tkrAccountValidationResultEntry -> + gatewayRequestCreator.crateErrorTkrToGateway( + tkrAccountValidationResultEntry.getKey(), + tkrAccountValidationResultEntry.getValue().errorMsg() + )) + .toList(); + sendTkrRequest.getTkrs().addAll(tkrs); + sendTkrRequest.getTkrs().addAll(eksTkrs); kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest); return null; } - //unwrap запроса + processAccount(accountsAfterValidation, gatewayRequest); + processEksAccount(eksAccountsAfterValidation, gatewayRequest); + kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest); + return null; + } + + private void processAccount(Map accountsAfterValidation, TkrAccountsGatewayRequest gatewayRequest) { + SendTkrRequest sendTkrRequest = new SendTkrRequest(); + sendTkrRequest.setRequestId(gatewayRequest.getRequestId()); + for (Map.Entry entry : accountsAfterValidation.entrySet()) { ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest(); TkrAccount tkrAccount = entry.getKey(); @@ -148,8 +193,45 @@ public class ClientCodeMessageListener extends QueueConsumer implements Initiali sendTkrRequest.getTkrs().add(gatewayRequestCreator.createTkrGatewayReq(tradingClearingRegistry)); log.debug("Success created new clientCode by tkr account: {}", tkrAccount.getClientCode()); } - kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest); - return null; + } + + private void processEksAccount(Map accountsAfterValidation, TkrAccountsGatewayRequest gatewayRequest) { + SendTkrRequest sendTkrRequest = new SendTkrRequest(); + sendTkrRequest.setRequestId(gatewayRequest.getRequestId()); + + for (Map.Entry entry : accountsAfterValidation.entrySet()) { + TkrAccount tkrAccount = entry.getKey(); + ValidationResult validationResult = entry.getValue(); + IValidator validator = validationResult.validator(); + Company company = validator.getStored(ClientCodeStoreObjects.COMPANY); + accountFacade.createInfoAccount(tkrAccount, company); + + ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest(); + log.debug("Creating new clientCode by tkr account: {}", tkrAccount.getClientCode()); + + Optional depoAccount = validator.getStored(ClientCodeStoreObjects.DEPO_ACCOUNT); + Long depoAccountId = depoAccount.map(Account::getId).orElse(null); +// Map accountByCurrency = validator.getStored(ClientCodeStoreObjects.MAPPED_TO_CURRENCY_ACCOUNTS); +// +// clientCodeNewRequest.setCompanyId(company.getId()); +// clientCodeNewRequest.setCode(tkrAccount.getClientCode()); +// clientCodeNewRequest.setDepoAccountId(depoAccountId); +// Account moneyAccount = accountByCurrency.get(CurrencyCode.RUB.getKey()); +// clientCodeNewRequest.setMoneyAccountId(moneyAccount.getId()); +// +// List foreignCurrencyList = accountByCurrency.entrySet() +// .stream() +// .filter(currencyCodeAccountEntry -> !CurrencyCode.RUB.equalsByKey(currencyCodeAccountEntry.getKey())) +// .map(currencyCodeAccountEntry -> currencyCodeAccountEntry.getValue().getId()) +// .toList(); +// clientCodeNewRequest.setCurrencyAccountList(foreignCurrencyList); +// clientCodeFacade.createClientCode(clientCodeNewRequest, validator); +// +// TradingClearingRegistry tradingClearingRegistry = selectTradingClearingRegistry(company.getId(), +// moneyAccount.getId(), depoAccountId); +// sendTkrRequest.getTkrs().add(gatewayRequestCreator.createTkrGatewayReq(tradingClearingRegistry)); +// log.debug("Success created new clientCode by tkr account: {}", tkrAccount.getClientCode()); + } } private RequestInfoUpdate clientCodeNewFromBackend(BaseRequest clientCodeNewRequest) { diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/validators/ClientCodeValidator.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/validators/ClientCodeValidator.java index 89f2eed9d..516519748 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/validators/ClientCodeValidator.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/validators/ClientCodeValidator.java @@ -24,6 +24,7 @@ public class ClientCodeValidator { private final Function clientCodeUpdateRequestValidator; private final Function clientCodeDeleteRequestValidator; private final Function tkrAccountsGatewayValidator; + private final Function tkrEksAccountsGatewayValidator; private final IMessageResolver messageResolver; public ClientCodeValidator(UserRoleVerification userRoleVerification, @@ -31,12 +32,14 @@ public class ClientCodeValidator { Function clientCodeUpdateRequestValidator, Function clientCodeDeleteRequestValidator, Function tkrAccountsGatewayValidator, + Function tkrEksAccountsGatewayValidator, IMessageResolver messageResolver) { this.userRoleVerification = userRoleVerification; this.clientCodeNewRequestValidator = clientCodeNewRequestValidator; this.clientCodeUpdateRequestValidator = clientCodeUpdateRequestValidator; this.clientCodeDeleteRequestValidator = clientCodeDeleteRequestValidator; this.tkrAccountsGatewayValidator = tkrAccountsGatewayValidator; + this.tkrEksAccountsGatewayValidator = tkrEksAccountsGatewayValidator; this.messageResolver = messageResolver; } @@ -44,6 +47,10 @@ public class ClientCodeValidator { return standardValidation(tkrAccountsGatewayValidator, gatewayAccountRequest); } + public ValidationResult checkGatewayRequestWithEksAcc(TkrAccount gatewayAccountRequest) { + return standardValidation(tkrEksAccountsGatewayValidator, gatewayAccountRequest); + } + public ValidationResult checkBackendNewRequest(ClientCodeNewRequest clientCodeNewRequest) { return standardValidation(clientCodeNewRequestValidator, clientCodeNewRequest); } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/GatewayClientCodeValidationRule.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/GatewayClientCodeValidationRule.java index a87115f75..b680a7eac 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/GatewayClientCodeValidationRule.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/GatewayClientCodeValidationRule.java @@ -7,6 +7,8 @@ import java.util.Map; import java.util.Optional; import org.springframework.util.StringUtils; import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.account.AccountSymbols; +import ru.clearing.classes.statics.data.account.DepoAccount; import ru.clearing.classes.statics.data.company.Company; import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList; @@ -96,9 +98,18 @@ public enum GatewayClientCodeValidationRule implements IValidationRule imdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); - Account depoAccount = imdg.getFirstObjectByFieldValues( - Map.of("account", depoAccountVal) + Imdg accountSymbolsImdg = context.obtainMap(IMDGDistributedNames.Map_AccountSymbols, AccountSymbols.class); + ImdgPredicateBuilder predicateBuilder = accountSymbolsImdg.predicateBuilder(); + AccountSymbols accountSymbols = accountSymbolsImdg.getSingleObjectByPredicate( + predicateBuilder.equals("accountSymbolValue", depoAccountVal) + ); + + if (accountSymbols == null) { + return of(AccountError.DepoAccountNotFound, "depo_account"); + } + Imdg imdg = context.obtainMap(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class); + DepoAccount depoAccount = imdg.getFirstObjectByPredicate( + predicateBuilder.equals("accountId", accountSymbols.getAccountId()) ); if (depoAccount == null) { context.storeObject(ClientCodeStoreObjects.DEPO_ACCOUNT, Optional.empty()); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/GatewayEksClientCodeValidationRule.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/GatewayEksClientCodeValidationRule.java new file mode 100644 index 000000000..9e6a85bc0 --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/validation/GatewayEksClientCodeValidationRule.java @@ -0,0 +1,93 @@ +package ru.spcex.clearing.account.validation; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.util.StringUtils; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; +import ru.spcex.clearing.account.errors.AccountError; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccount; +import ru.spcex.clearing.platform.messaging.domain.cud.gateway.MoneyAccountMsgRequest; +import ru.spcex.platform.enumeration.CurrencyCode; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.validation.IValidationRule; + +public enum GatewayEksClientCodeValidationRule implements IValidationRule> { + CompanyPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + TkrAccount validatedObject = context.getValidatedObject(); + Long tradingCode = validatedObject.getTradingCode(); + if (tradingCode == null) { + return of(AccountError.RequiredFieldEmpty, "trading_code"); + } + + Imdg companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class); + Company company = companyImdg.getFirstObjectByFieldValues( + Map.of("tradingCode", String.valueOf(tradingCode)) + ); + if (company == null) { + return of(AccountError.COMPANY_NOT_FOUND_GTW, "trading_code"); + } + + context.storeObject(ClientCodeStoreObjects.COMPANY, company); + return Optional.empty(); + } + }, + AllAccountsPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + TkrAccount validatedObject = context.getValidatedObject(); + List accountList = validatedObject.getMoneyAccounts(); + if (accountList == null || accountList.isEmpty()) { + return of(AccountError.RequiredFieldEmpty, "money_account"); + } + List currencies = accountList.stream().map(MoneyAccountMsgRequest::getCurrCode).toList(); + if (!currencies.contains(CurrencyCode.RUB.getKey())) { + return of(AccountError.RequiredFieldEmpty, "money_account"); + } + Imdg imdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Map accountByCurrency = new HashMap<>(); + for (MoneyAccountMsgRequest moneyAccountMsg : accountList) { + //если в списке есть eksAccount то проверим, что его нет в системе + if (!StringUtils.hasText(moneyAccountMsg.getEks_account())) { + return of(AccountError.RequiredFieldEmpty, "eks_account"); + } + } + context.storeObject(ClientCodeStoreObjects.MAPPED_TO_CURRENCY_ACCOUNTS, accountByCurrency); + return Optional.empty(); + } + }, + DepoAccountsPresent() { + @Override + public Optional validate(ImdgValidationContext context) { + TkrAccount validatedObject = context.getValidatedObject(); + String depoAccountVal = validatedObject.getDepoAccount(); + if (!StringUtils.hasText(depoAccountVal)) { + context.storeObject(ClientCodeStoreObjects.DEPO_ACCOUNT, Optional.empty()); + return empty(); + } + + Imdg imdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + Account depoAccount = imdg.getFirstObjectByFieldValues( + Map.of("account", depoAccountVal) + ); + if (depoAccount == null) { + context.storeObject(ClientCodeStoreObjects.DEPO_ACCOUNT, Optional.empty()); + return of(AccountError.DepoAccountNotFound, "depo_account"); + } + + context.storeObject(ClientCodeStoreObjects.DEPO_ACCOUNT, depoAccount); + return Optional.empty(); + } + }; + + private static final Logger log = LoggerFactory.getLogger(GatewayEksClientCodeValidationRule.class); +} diff --git a/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/TkrAdapter.java b/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/TkrAdapter.java index ff7f04e9a..57de4f74d 100644 --- a/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/TkrAdapter.java +++ b/clearing-parent/gateway-api/src/main/java/ru/spcex/clearing/gatewayapi/service/adapter/TkrAdapter.java @@ -54,6 +54,7 @@ public class TkrAdapter { MoneyAccountMsgRequest moneyAccountMsg = new MoneyAccountMsgRequest(); moneyAccountMsg.setAccount(moneyAccount.getAccount()); moneyAccountMsg.setCurrCode(moneyAccount.getCurrCode()); + moneyAccountMsg.setEks_account(moneyAccount.getEksAccount()); return moneyAccountMsg; } } diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/gateway/MoneyAccountMsgRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/gateway/MoneyAccountMsgRequest.java index bb2a87322..808db6748 100644 --- a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/gateway/MoneyAccountMsgRequest.java +++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/gateway/MoneyAccountMsgRequest.java @@ -7,6 +7,8 @@ public class MoneyAccountMsgRequest { private String currCode; @JsonProperty("account") private String account; + @JsonProperty("eks_account") + private String eks_account; @JsonProperty("status") private String status; @@ -25,4 +27,12 @@ public class MoneyAccountMsgRequest { public void setAccount(String account) { this.account = account; } + + public String getEks_account() { + return eks_account; + } + + public void setEks_account(String eks_account) { + this.eks_account = eks_account; + } }