new version services [account-service]

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClientCodeValidationConfig.java

@@ -1,5 +1,6 @@
 package ru.spcex.clearing.account.config.validation;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -13,8 +14,10 @@ import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.ClientCode;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.company.CompanySymbols;
+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.account.validation.ClientCodeStoreObjects;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeUpdateRequest;
@@ -27,6 +30,7 @@ import ru.spcex.clearing.validation.common.rules.IdPresentRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.CompanySymbol;
 import ru.spcex.platform.enumeration.CurrencyCode;
+import ru.spcex.platform.enumeration.Status;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
@@ -50,45 +54,149 @@ public class ClientCodeValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
             addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
             return new ValidatorImpl<>(context,
-                    FieldRequiredRule.instance("companyId", ClientCodeNewRequest::getCompanyId, AccountError.RequiredFieldEmpty),
+                FieldRequiredRule.instance("companyId", ClientCodeNewRequest::getCompanyId, AccountError.RequiredFieldEmpty),
-                    IdPresentRule.instance("companyId",
+                IdPresentRule.instance("companyId",
-                            ClientCodeNewRequest::getCompanyId,
+                    ClientCodeNewRequest::getCompanyId,
-                            IMDGDistributedNames.Map_Company,
+                    IMDGDistributedNames.Map_Company,
-                            Company.class,
+                    Company.class,
-                            AccountError.RequiredFieldEmpty,
+                    AccountError.RequiredFieldEmpty,
-                            AccountError.CompanyNotFound),
+                    AccountError.CompanyNotFound),
 
-                    IdPresentRule.instance("moneyAccountId",
+                IdPresentRule.instance("moneyAccountId",
-                            ClientCodeNewRequest::getMoneyAccountId,
+                    ClientCodeNewRequest::getMoneyAccountId,
-                            IMDGDistributedNames.Map_Account,
+                    IMDGDistributedNames.Map_Account,
-                            Account.class,
+                    Account.class,
-                            AccountError.RequiredFieldEmpty,
+                    AccountError.RequiredFieldEmpty,
-                            AccountError.AccountNotFound,
+                    AccountError.AccountNotFound,
-                            false,
+                    false,
-                            acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
+                    acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
-                                    ? null : AccountError.AccountNotFound
+                        ? null : AccountError.AccountNotFound
-                            ),
+                ),
-                    IdPresentRule.instance("depoAccountId",
+                IdPresentRule.instance("depoAccountId",
-                            ClientCodeNewRequest::getDepoAccountId,
+                    ClientCodeNewRequest::getDepoAccountId,
-                            IMDGDistributedNames.Map_Account,
+                    IMDGDistributedNames.Map_Account,
-                            Account.class,
+                    Account.class,
-                            AccountError.RequiredFieldEmpty,
+                    AccountError.RequiredFieldEmpty,
-                            AccountError.AccountNotFound,
+                    AccountError.AccountNotFound,
-                            false,
+                    false,
-                            acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
+                    acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
-                                    ? null : AccountError.AccountNotFound
+                        ? null : AccountError.AccountNotFound
-                    ),
+                ),
-                    new ExistAllCurrencyAccountId<>("currencyAccountList",
+                new ExistAllCurrencyAccountId<>("currencyAccountList",
-                            ClientCodeNewRequest::getCurrencyAccountList
+                    ClientCodeNewRequest::getCurrencyAccountList
-                    ),
+                ),
 
-                    DictionaryPresentRule.instance("stauts",
+                DictionaryPresentRule.instance("stauts",
-                            ClientCodeNewRequest::getStatus,
+                    ClientCodeNewRequest::getStatus,
-                            IMDGDistributedNames.Map_ServiceStatusDictionary,
+                    IMDGDistributedNames.Map_ServiceStatusDictionary,
-                            ServiceStatusDictionary.class,
+                    ServiceStatusDictionary.class,
-                            AccountError.RequiredFieldEmpty,
+                    AccountError.RequiredFieldEmpty,
-                            AccountError.DictionaryNotFound,
+                    AccountError.DictionaryNotFound,
-                            false)
+                    false)
+            );
+        };
+    }
+
+    @Bean("clientCodeUpdateRequestValidator")
+    public Function<ClientCodeUpdateRequest, IValidator> clientCodeUpdateRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return clientCodeUpdateRequest -> {
+            ImdgValidationContext<ClientCodeUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(clientCodeUpdateRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_ClientCode);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
+            return new ValidatorImpl<ImdgValidationContext<ClientCodeUpdateRequest>>(context,
+                IdPresentRule.instance("id",
+                    ClientCodeUpdateRequest::getId,
+                    IMDGDistributedNames.Map_ClientCode,
+                    ClientCode.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.RecordNotFound
+                ),
+
+                FieldRequiredRule.instance("companyId", ClientCodeUpdateRequest::getCompanyId, AccountError.RequiredFieldEmpty),
+                IdPresentRule.instance("companyId",
+                    ClientCodeUpdateRequest::getCompanyId,
+                    IMDGDistributedNames.Map_Company,
+                    Company.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.CompanyNotFound),
+
+                IdPresentRule.instance("moneyAccountId",
+                    ClientCodeUpdateRequest::getMoneyAccountId,
+                    IMDGDistributedNames.Map_Account,
+                    Account.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.AccountNotFound,
+                    true,
+                    acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
+                        ? null : AccountError.AccountNotFound
+                ),
+                IdPresentRule.instance("depoAccountId",
+                    ClientCodeUpdateRequest::getDepoAccountId,
+                    IMDGDistributedNames.Map_Account,
+                    Account.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.AccountNotFound,
+                    false,
+                    acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
+                        ? null : AccountError.AccountNotFound
+                ),
+                new ExistAllCurrencyAccountId<>("currencyAccountList",
+                    ClientCodeUpdateRequest::getCurrencyAccountList
+                ),
+
+                DictionaryPresentRule.instance("stauts",
+                    ClientCodeUpdateRequest::getStatus,
+                    IMDGDistributedNames.Map_ServiceStatusDictionary,
+                    ServiceStatusDictionary.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.DictionaryNotFound,
+                    false)
+            );
+        };
+    }
+
+    @Bean("clientCodeDeleteRequestValidator")
+    public Function<CommonDeleteRequest, IValidator> clientCodeDeleteRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return companyDeleteRequest -> {
+            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(companyDeleteRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_ClientCode);
+            return new ValidatorImpl<>(context,
+//                    FieldRequiredRule.instance("id", CommonDeleteRequest::getId, CompanyErrors.RequiredFieldEmpty),
+                IdPresentRule.instance("id",
+                    CommonDeleteRequest::getId,
+                    IMDGDistributedNames.Map_ClientCode,
+                    ClientCode.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.RecordNotFound)
+            );
+        };
+    }
+
+    @Bean("tkrAccountsGatewayValidator")
+    public Function<TkrAccount, IValidator> tkrAccountsGatewayValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return tkrGatewayRequest -> {
+            ImdgValidationContext<TkrAccount> context = new ImdgValidationContext<>();
+            context.setValidatedObject(tkrGatewayRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_CompanySymbols);
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            return new ValidatorImpl<>(context,
+                new ExistCompanyByUuid<>("companySymbolValue",
+                    TkrAccount::getCompanyId),
+                new ExistAccountByValue<>("account",
+                    TkrAccount::getMoneyAccounts),
+                new ExistDepoAccountByValue<>("depo_account",
+                    TkrAccount::getDepoAccount),
+                new ExistTcrByCode<>("tcr_code",
+                    TkrAccount::getTkrCode)
             );
         };
     }
@@ -110,7 +218,7 @@ public class ClientCodeValidationConfig {
                 return empty(); // необязательное поле
             }
             Imdg<Account> imdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
-            for (Long id:ids) {
+            for (Long id : ids) {
                 if (id == null) { // null значения в массиве не ожидаются
                     return of(AccountError.RequiredFieldEmpty, fieldName);
                 }
@@ -128,6 +236,43 @@ public class ClientCodeValidationConfig {
         }
     }
 
+    public static class ExistTcrByCode<R> implements IValidationRule<ImdgValidationContext<R>> {
+        String fieldName;
+        Function<R, String> codeGetter;
+
+        public ExistTcrByCode(String fieldName, Function<R, String> codeGetter) {
+            this.fieldName = fieldName;
+            this.codeGetter = codeGetter;
+        }
+
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<R> context) {
+            R validatedObject = context.getValidatedObject();
+            String tcrCode = codeGetter.apply(validatedObject);
+            if (!StringUtils.hasText(tcrCode)) {
+                return of(AccountError.RequiredFieldEmpty, fieldName);
+            }
+            Imdg<TradingClearingRegistry> imdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry,
+                TradingClearingRegistry.class);
+
+            TradingClearingRegistry tcr = imdg.getFirstObjectByFieldValues(
+                Map.of(
+                    "code", tcrCode,
+                    "status", Status.Active.getKey()
+                )
+            );
+            if (tcr != null) {
+                return of(AccountError.TCR_ALREADY_EXIST_GTW, fieldName);
+            }
+            return Optional.empty();
+        }
+
+        @Override
+        public String ruleName() {
+            return getClass().getSimpleName() + "{" + fieldName + "}";
+        }
+    }
+
     public static class ExistCompanyByUuid<R> implements IValidationRule<ImdgValidationContext<R>> {
         String fieldName;
         Function<R, String> symbolCodeGetter;
@@ -151,9 +296,17 @@ public class ClientCodeValidationConfig {
                     "companySymbolValue", symbolCodeValue
                 )
             );
-            if (companySymbols == null) { // null значения в массиве не ожидаются
+            if (companySymbols == null) {
                 return of(AccountError.COMPANY_NOT_FOUND_GTW, fieldName);
             }
+
+            Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
+            Company company = companyImdg.getSingleObjectByID(companySymbols.getCompanyId());
+            if (company == null) {
+                return of(AccountError.COMPANY_NOT_FOUND_GTW, fieldName);
+            }
+
+            context.storeObject(ClientCodeStoreObjects.COMPANY, company);
             return Optional.empty();
         }
 
@@ -179,7 +332,12 @@ public class ClientCodeValidationConfig {
             if (accountList == null || accountList.isEmpty()) {
                 return of(AccountError.RequiredFieldEmpty, fieldName);
             }
+            List<String> currencies = accountList.stream().map(MoneyAccountMsgRequest::getCurrCode).toList();
+            if (!currencies.contains(CurrencyCode.RUB.getKey())) {
+                return of(AccountError.RequiredFieldEmpty, fieldName);
+            }
             Imdg<Account> imdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            Map<String, Account> accountByCurrency = new HashMap<>();
             for (MoneyAccountMsgRequest moneyAccountMsg : accountList) {
                 ImdgPredicateBuilder predicateBuilder = imdg.predicateBuilder();
                 ImdgPredicate currencyPredicate;
@@ -198,7 +356,9 @@ public class ClientCodeValidationConfig {
                 if (account == null) {
                     return of(AccountError.ACCOUNT_NOT_FOUND_GTW, moneyAccountMsg.getAccount(), fieldName);
                 }
+                accountByCurrency.put(account.getCurrency(), account);
             }
+            context.storeObject(ClientCodeStoreObjects.MAPPED_TO_CURRENCY_ACCOUNTS, accountByCurrency);
             return Optional.empty();
         }
 
@@ -208,103 +368,40 @@ public class ClientCodeValidationConfig {
         }
     }
 
-    @Bean("clientCodeUpdateRequestValidator")
+    public static class ExistDepoAccountByValue<R> implements IValidationRule<ImdgValidationContext<R>> {
-    public Function<ClientCodeUpdateRequest, IValidator> clientCodeUpdateRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        String fieldName;
-        return clientCodeUpdateRequest -> {
+        Function<R, String> depoAccountGetter;
-            ImdgValidationContext<ClientCodeUpdateRequest> context = new ImdgValidationContext<>();
-            context.setValidatedObject(clientCodeUpdateRequest);
-            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
-            addImdg.accept(IMDGDistributedNames.Map_ClientCode);
-            addImdg.accept(IMDGDistributedNames.Map_Company);
-            addImdg.accept(IMDGDistributedNames.Map_Account);
-            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
-            addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
-            return new ValidatorImpl<ImdgValidationContext<ClientCodeUpdateRequest>>(context,
-                    IdPresentRule.instance("id",
-                            ClientCodeUpdateRequest::getId,
-                            IMDGDistributedNames.Map_ClientCode,
-                            ClientCode.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.RecordNotFound
-                    ),
 
-                    FieldRequiredRule.instance("companyId", ClientCodeUpdateRequest::getCompanyId, AccountError.RequiredFieldEmpty),
+        public ExistDepoAccountByValue(String fieldName, Function<R, String> accountsListValueGetter) {
-                    IdPresentRule.instance("companyId",
+            this.fieldName = fieldName;
-                            ClientCodeUpdateRequest::getCompanyId,
+            this.depoAccountGetter = depoAccountGetter;
-                            IMDGDistributedNames.Map_Company,
+        }
-                            Company.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.CompanyNotFound),
 
-                    IdPresentRule.instance("moneyAccountId",
+        @Override
-                            ClientCodeUpdateRequest::getMoneyAccountId,
+        public Optional<EnumMessage> validate(ImdgValidationContext<R> context) {
-                            IMDGDistributedNames.Map_Account,
+            R validatedObject = context.getValidatedObject();
-                            Account.class,
+            String depoAccountVal = depoAccountGetter.apply(validatedObject);
-                            AccountError.RequiredFieldEmpty,
+            if (!StringUtils.hasText(depoAccountVal)) {
-                            AccountError.AccountNotFound,
+                context.storeObject(ClientCodeStoreObjects.DEPO_ACCOUNT,Optional.empty());
-                            true,
+                return empty();
-                            acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
+            }
-                                    ? null : AccountError.AccountNotFound
-                    ),
-                    IdPresentRule.instance("depoAccountId",
-                            ClientCodeUpdateRequest::getDepoAccountId,
-                            IMDGDistributedNames.Map_Account,
-                            Account.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.AccountNotFound,
-                            false,
-                            acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
-                                    ? null : AccountError.AccountNotFound
-                    ),
-                    new ExistAllCurrencyAccountId<>("currencyAccountList",
-                            ClientCodeUpdateRequest::getCurrencyAccountList
-                    ),
 
-                    DictionaryPresentRule.instance("stauts",
+            Imdg<Account> imdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
-                            ClientCodeUpdateRequest::getStatus,
+            Account depoAccount = imdg.getFirstObjectByFieldValues(
-                            IMDGDistributedNames.Map_ServiceStatusDictionary,
+                Map.of("account", depoAccountVal)
-                            ServiceStatusDictionary.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.DictionaryNotFound,
-                            false)
             );
-        };
+            if (depoAccount == null) {
-    }
+                context.storeObject(ClientCodeStoreObjects.DEPO_ACCOUNT,Optional.empty());
+                return of(AccountError.DEPO_ACCOUNT_NOT_FOUND_GTW, fieldName);
+            }
 
-    @Bean("clientCodeDeleteRequestValidator")
+            context.storeObject(ClientCodeStoreObjects.DEPO_ACCOUNT, depoAccount);
-    public Function<CommonDeleteRequest, IValidator> clientCodeDeleteRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+            return Optional.empty();
-        return companyDeleteRequest -> {
+        }
-            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
-            context.setValidatedObject(companyDeleteRequest);
-            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
-            addImdg.accept(IMDGDistributedNames.Map_ClientCode);
-            return new ValidatorImpl<>(context,
-//                    FieldRequiredRule.instance("id", CommonDeleteRequest::getId, CompanyErrors.RequiredFieldEmpty),
-                    IdPresentRule.instance("id",
-                            CommonDeleteRequest::getId,
-                            IMDGDistributedNames.Map_ClientCode,
-                            ClientCode.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.RecordNotFound)
-            );
-        };
-    }
 
-    @Bean("tkrAccountsGatewayValidator")
+        @Override
-    public Function<TkrAccount, IValidator> tkrAccountsGatewayValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        public String ruleName() {
-        return tkrGatewayRequest -> {
+            return getClass().getSimpleName() + "{" + fieldName + "}";
-            ImdgValidationContext<TkrAccount> context = new ImdgValidationContext<>();
+        }
-            context.setValidatedObject(tkrGatewayRequest);
-            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
-            addImdg.accept(IMDGDistributedNames.Map_CompanySymbols);
-            addImdg.accept(IMDGDistributedNames.Map_Account);
-            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
-            return new ValidatorImpl<>(context,
-                new ExistCompanyByUuid<>("companySymbolValue",
-                    TkrAccount::getCompanyId),
-                new ExistAccountByValue<>("account",
-                    TkrAccount::getMoneyAccounts)
-            );
-        };
     }
 }

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java

@@ -29,6 +29,8 @@ public enum AccountError implements IErrorEnumId {
     TCR_NOT_FOUND_GTW(5028L),
     ACCOUNT_NOT_FOUND_GTW(5029L),
     COMPANY_NOT_FOUND_GTW(5030L),
+    TCR_ALREADY_EXIST_GTW(5031L),
+    DEPO_ACCOUNT_NOT_FOUND_GTW(5032L),
     TradingClearingRegistryNotFound(3022L),
     CurrencyNotFound(1016L),
     ;

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/TradingClearingRegistryFacade.java

@@ -30,28 +30,24 @@ public class TradingClearingRegistryFacade {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final ImdgProvider imdgProvider;
     private final KafkaSender kafkaSender;
+    private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
+    private final Imdg<DepoAccount> depoAccountImdg;
+    private final Imdg<ClearingAccount> clearingAccountImdg;
+    private final Imdg<Company> companyImdg;
 
     public TradingClearingRegistryFacade(ImdgProvider imdgProvider,
                                          KafkaSender kafkaSender) {
         this.imdgProvider = imdgProvider;
+        this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry,
+            TradingClearingRegistry.class);
+        this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
+        this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
+        this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.kafkaSender = kafkaSender;
     }
 
     public TradingClearingRegistry createTradingClearingRegistry(TradingClearingRegistryNewRequest request,
                                                                  IValidator validator) {
-        Imdg<TradingClearingRegistry> tradingClearingRegistryImdg = imdgProvider.getImdg(
-            IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class
-        );
-        Imdg<DepoAccount> depoAccountImdg = imdgProvider.getImdg(
-            IMDGDistributedNames.Map_DepoAccount, DepoAccount.class
-        );
-        Imdg<ClearingAccount> clearingAccountImdg = imdgProvider.getImdg(
-            IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class
-        );
-        Imdg<Company> companyImdg = imdgProvider.getImdg(
-            IMDGDistributedNames.Map_Company, Company.class
-        );
-
         Long id = tradingClearingRegistryImdg.nextIDSequenceFor();
         TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry();
         tradingClearingRegistry.setId(id);

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/facade/TradingClearingRegistryListFacade.java

@@ -24,10 +24,18 @@ public class TradingClearingRegistryListFacade {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final ImdgProvider imdgProvider;
     private final KafkaSender kafkaSender;
+    private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
+    private final Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg;
+    private final Imdg<Account> accountImdg;
 
     public TradingClearingRegistryListFacade(ImdgProvider imdgProvider,
                                              KafkaSender kafkaSender) {
         this.imdgProvider = imdgProvider;
+        this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry,
+            TradingClearingRegistry.class);
+        this.tradingClearingRegistryListImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList,
+            TradingClearingRegistryList.class);
+        this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.kafkaSender = kafkaSender;
     }
 
@@ -36,20 +44,10 @@ public class TradingClearingRegistryListFacade {
         Account account;
 
     }
+
     public List<Long> createTradingClearingRegistryList(TradingClearingRegistryListNewRequest request,
                                                         Stored stored) {
-        Imdg<TradingClearingRegistry> tradingClearingRegistryImdg = imdgProvider.getImdg(
-            IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class
-        );
-        Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg = imdgProvider.getImdg(
-            IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class
-        );
-        Imdg<Account> accountImdg = imdgProvider.getImdg(
-            IMDGDistributedNames.Map_Account, Account.class
-        );
-
         TradingClearingRegistry tcr = tradingClearingRegistryImdg.getSingleObjectByID(request.getTradingClearingRegistryId());
-
         Instant now = Instant.now();
 
         List<Long> newIds = new ArrayList<>();

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/listeners/ClientCodeMessageListener.java

@@ -114,7 +114,7 @@ public class ClientCodeMessageListener extends QueueConsumer implements Initiali
             Company company = validator.getStored(ClientCodeStoreObjects.COMPANY);
             Optional<Account> depoAccount = validator.getStored(ClientCodeStoreObjects.DEPO_ACCOUNT);
             Long depoAccountId = depoAccount.map(Account::getId).orElse(null);
-            Map<CurrencyCode, Account> accountByCurrency = validator.getStored(ClientCodeStoreObjects.MAPPED_TO_CURRENCY_ACCOUNTS);
+            Map<String, Account> accountByCurrency = validator.getStored(ClientCodeStoreObjects.MAPPED_TO_CURRENCY_ACCOUNTS);
 
             clientCodeNewRequest.setCompanyId(company.getId());
             clientCodeNewRequest.setCode(tkrAccount.getClientCode());
@@ -124,7 +124,7 @@ public class ClientCodeMessageListener extends QueueConsumer implements Initiali
 
             List<Long> foreignCurrencyList = accountByCurrency.entrySet()
                 .stream()
-                .filter(currencyCodeAccountEntry -> CurrencyCode.RUB != currencyCodeAccountEntry.getKey())
+                .filter(currencyCodeAccountEntry -> !CurrencyCode.RUB.equalsByKey(currencyCodeAccountEntry.getKey()))
                 .map(currencyCodeAccountEntry -> currencyCodeAccountEntry.getValue().getId())
                 .toList();
             clientCodeNewRequest.setCurrencyAccountList(foreignCurrencyList);