remove all comments

This reverts commit 7886d13a24.

clearing-parent/account-service/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>clearing-parent</artifactId>
         <groupId>ru.spcex.clearing</groupId>
-        <version>SPCEX-1.0.0.0</version>
+        <version>SPCEX-3.12.2</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -48,6 +48,12 @@
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
         </dependency>
+        <!-- special logging -->
+        <dependency>
+            <groupId>net.logstash.logback</groupId>
+            <artifactId>logstash-logback-encoder</artifactId>
+            <version>7.0.1</version>
+        </dependency>
         <!-- TEST -->
         <dependency>
             <groupId>ru.spcex.clearing</groupId>

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

@@ -1,5 +1,10 @@
 package ru.spcex.clearing.account.config.validation;
 
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import ru.clearing.classes.statics.data.account.Account;
@@ -22,17 +27,12 @@ import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.imdg.validation.rule.CurrencyCodeValidationRule;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.validation.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
 
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
 @Configuration
 public class AccountValidationConfig {
 
@@ -48,14 +48,15 @@ public class AccountValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_Account);
             addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
             addImdg.accept(IMDGDistributedNames.Map_AccountTypeDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_Currency);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("companyId",
-                            CorrespondentAccountNewRequest::getCompanyId,
-                            IMDGDistributedNames.Map_Company,
-                            Company.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.CompanyNotFound
-//                            company -> WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? null : AccountError.CompanyNotActive
+                        CorrespondentAccountNewRequest::getCompanyId,
+                        IMDGDistributedNames.Map_Company,
+                        Company.class,
+                        AccountError.RequiredFieldEmpty,
+                        AccountError.CompanyNotFound
                     ),
                     FieldRequiredSpecificRule.instance("account",
                             CorrespondentAccountNewRequest::getAccount,
@@ -79,16 +80,12 @@ public class AccountValidationConfig {
                                 return new EnumMessage(AccountError.AccountAlreadyExist, accounts.stream().findFirst().get().getAccount());
                             }),
                     DictionaryPresentRule.instance("status",
-                            CorrespondentAccountNewRequest::getStatus,
-                            IMDGDistributedNames.Map_ServiceStatusDictionary,
-                            ServiceStatusDictionary.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.DictionaryNotFound,
-                            false
-//                           , statusValue -> {
-//                                if (ServiceStatus.Active.equalsByKey(statusValue.getCode())) return null;
-//                                return AccountError.WrongFieldValue;
-//                            }
+                        CorrespondentAccountNewRequest::getStatus,
+                        IMDGDistributedNames.Map_ServiceStatusDictionary,
+                        ServiceStatusDictionary.class,
+                        AccountError.RequiredFieldEmpty,
+                        AccountError.DictionaryNotFound,
+                        false
                     ),
                     DictionaryPresentRule.instance("accountType",
                             CorrespondentAccountNewRequest::getAccountType,
@@ -106,6 +103,16 @@ public class AccountValidationConfig {
                                     return DictionaryPresentRule.DICTIONARY_NOT_FOUND_DECORATOR_2.decorator(causeEmpty, errorCode, fieldName, fieldValue);
                             }
                             ),
+
+                    DictionaryPresentRule.instance("currency",
+                            CorrespondentAccountNewRequest::getCurrency,
+                            IMDGDistributedNames.Map_CurrencyCodeDictionary,
+                            ServiceStatusDictionary.class,
+                            null,
+                            AccountError.DictionaryNotFound,
+                            false
+                    ),
+                    CurrencyCodeValidationRule.get(AccountError.CurrencyNotFound),
                     new SameAccountValidationRule<>(AccountType.Corr, CorrespondentAccountNewRequest::getAccount)
             );
         };
@@ -150,16 +157,12 @@ public class AccountValidationConfig {
                             AccountError.DictionaryNotFound,
                             false),
                     DictionaryPresentRule.instance("accountType",
-                            CorrespondentAccountUpdateRequest::getAccountType,
-                            IMDGDistributedNames.Map_AccountTypeDictionary,
-                            AccountTypeDictionary.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.DictionaryNotFound,
-                            false
-//                            accountType -> {
-//                                if (AccountType.Corr.equalsByKey(accountType.getCode())) return null;
-//                                return AccountError.WrongFieldValue;
-//                            }
+                        CorrespondentAccountUpdateRequest::getAccountType,
+                        IMDGDistributedNames.Map_AccountTypeDictionary,
+                        AccountTypeDictionary.class,
+                        AccountError.RequiredFieldEmpty,
+                        AccountError.DictionaryNotFound,
+                        false
                     )
             );
         };

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

@@ -106,11 +106,10 @@ public class BankAccountValidationConfig {
                             bankAccount -> {
                                 Long accountId = bankAccount.getAccountId();
                                 Imdg<Account> accountImdg = context.obtainMap(
-                                        IMDGDistributedNames.Map_Account, Account.class
+                                    IMDGDistributedNames.Map_Account, Account.class
                                 );
                                 Account account = accountImdg.getSingleObjectByID(accountId);
                                 if (account == null) return AccountError.AccountNotFound;
-//                                if (!AccountStatus.ACTIVE.equalsByKey(account.getStatus())) return AccountError.AccountNotActive;
                                 return null;
                             }),
                     DictionaryPresentRule.instance("currency",

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

@@ -48,12 +48,11 @@ public class ClearingAccountValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("companyId",
-                            ClearingAccountNewRequest::getCompanyId,
-                            IMDGDistributedNames.Map_Company,
-                            Company.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.CompanyNotFound
-//                            company -> !WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? AccountError.CompanyNotActive : null
+                        ClearingAccountNewRequest::getCompanyId,
+                        IMDGDistributedNames.Map_Company,
+                        Company.class,
+                        AccountError.RequiredFieldEmpty,
+                        AccountError.CompanyNotFound
                     ),
                     FieldNotBlankRequiredRule.instance("account",
                             ClearingAccountNewRequest::getAccount,

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

@@ -1,5 +1,9 @@
 package ru.spcex.clearing.account.config.validation;
 
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import ru.clearing.classes.statics.data.account.Account;
@@ -7,9 +11,12 @@ import ru.clearing.classes.statics.data.account.ClientCode;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.platform.dictionary.ServiceStatusDictionary;
 import ru.spcex.clearing.account.errors.AccountError;
+import ru.spcex.clearing.account.validation.BackendClientCodeValidationRule;
+import ru.spcex.clearing.account.validation.GatewayClientCodeValidationRule;
 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;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccount;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
 import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
 import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
@@ -20,11 +27,6 @@ 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.Objects;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
 @Configuration
 public class ClientCodeValidationConfig {
 
@@ -37,45 +39,46 @@ public class ClientCodeValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_Company);
             addImdg.accept(IMDGDistributedNames.Map_Account);
             addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistryList);
             addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
             return new ValidatorImpl<>(context,
-                    FieldRequiredRule.instance("companyId", ClientCodeNewRequest::getCompanyId, AccountError.RequiredFieldEmpty),
-                    IdPresentRule.instance("companyId",
-                            ClientCodeNewRequest::getCompanyId,
-                            IMDGDistributedNames.Map_Company,
-                            Company.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.CompanyNotFound),
+                FieldRequiredRule.instance("companyId", ClientCodeNewRequest::getCompanyId, AccountError.RequiredFieldEmpty),
+                IdPresentRule.instance("companyId",
+                    ClientCodeNewRequest::getCompanyId,
+                    IMDGDistributedNames.Map_Company,
+                    Company.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.CompanyNotFound),
 
-                    IdPresentRule.instance("moneyAccountId",
-                            ClientCodeNewRequest::getMoneyAccountId,
-                            IMDGDistributedNames.Map_Account,
-                            Account.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.AccountNotFound,
-                            false,
-                            acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
-                                    ? null : AccountError.AccountNotFound
-                            ),
-                    IdPresentRule.instance("depoAccountId",
-                            ClientCodeNewRequest::getDepoAccountId,
-                            IMDGDistributedNames.Map_Account,
-                            Account.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.AccountNotFound,
-                            false,
-                            acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
-                                    ? null : AccountError.AccountNotFound
-                    ),
-
-
-                    DictionaryPresentRule.instance("stauts",
-                            ClientCodeNewRequest::getStatus,
-                            IMDGDistributedNames.Map_ServiceStatusDictionary,
-                            ServiceStatusDictionary.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.DictionaryNotFound,
-                            false)
+                IdPresentRule.instance("moneyAccountId",
+                    ClientCodeNewRequest::getMoneyAccountId,
+                    IMDGDistributedNames.Map_Account,
+                    Account.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.AccountNotFound,
+                    false,
+                    acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
+                        ? null : AccountError.AccountNotFound
+                ),
+                IdPresentRule.instance("depoAccountId",
+                    ClientCodeNewRequest::getDepoAccountId,
+                    IMDGDistributedNames.Map_Account,
+                    Account.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.AccountNotFound,
+                    false,
+                    acc -> Objects.equals(context.getValidatedObject().getCompanyId(), acc.getCompanyId())
+                        ? null : AccountError.AccountNotFound
+                ),
+                BackendClientCodeValidationRule.AllAccountsPresent,
+                BackendClientCodeValidationRule.TcrIsNotPresentByAccount,
+                DictionaryPresentRule.instance("status",
+                    ClientCodeNewRequest::getStatus,
+                    IMDGDistributedNames.Map_ServiceStatusDictionary,
+                    ServiceStatusDictionary.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.DictionaryNotFound,
+                    false)
             );
         };
     }
@@ -91,51 +94,51 @@ public class ClientCodeValidationConfig {
             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
-                    ),
+            return new ValidatorImpl<>(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),
+                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,
-                            false,
-                            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
-                    ),
-
-                    DictionaryPresentRule.instance("stauts",
-                            ClientCodeUpdateRequest::getStatus,
-                            IMDGDistributedNames.Map_ServiceStatusDictionary,
-                            ServiceStatusDictionary.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.DictionaryNotFound,
-                            false)
+                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
+                ),
+                BackendClientCodeValidationRule.AllAccountsPresent,
+                DictionaryPresentRule.instance("stauts",
+                    ClientCodeUpdateRequest::getStatus,
+                    IMDGDistributedNames.Map_ServiceStatusDictionary,
+                    ServiceStatusDictionary.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.DictionaryNotFound,
+                    false)
             );
         };
     }
@@ -148,14 +151,35 @@ public class ClientCodeValidationConfig {
             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)
+                IdPresentRule.instance("id",
+                    CommonDeleteRequest::getId,
+                    IMDGDistributedNames.Map_ClientCode,
+                    ClientCode.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.RecordNotFound)
             );
         };
     }
+
+    @Bean("tkrAccountsGatewayValidator")
+    public Function<TkrAccount, IValidator> newTkrAccountsGatewayValidator(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_Company);
+            addImdg.accept(IMDGDistributedNames.Map_CompanySymbols);
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            return new ValidatorImpl<>(context,
+                FieldRequiredRule.instance("client_code", TkrAccount::getClientCode, AccountError.RequiredFieldEmpty),
+                GatewayClientCodeValidationRule.CompanyPresent,
+                GatewayClientCodeValidationRule.AllAccountsPresent,
+                GatewayClientCodeValidationRule.DepoAccountsPresent,
+                GatewayClientCodeValidationRule.TcrIsNotPresent,
+                GatewayClientCodeValidationRule.TcrListIsNotPresent
+            );
+        };
+    }
+
 }

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

@@ -42,12 +42,11 @@ public class DepoAccountValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("companyId",
-                            DepoAccountNewRequest::getCompanyId,
-                            IMDGDistributedNames.Map_Company,
-                            Company.class,
-                            AccountError.RequiredFieldEmpty,
-                            AccountError.CompanyNotFound
-//                            company -> !WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? AccountError.CompanyNotActive : null
+                        DepoAccountNewRequest::getCompanyId,
+                        IMDGDistributedNames.Map_Company,
+                        Company.class,
+                        AccountError.RequiredFieldEmpty,
+                        AccountError.CompanyNotFound
                     ),
                     FieldNotBlankRequiredRule.instance("account",
                             DepoAccountNewRequest::getAccount,

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

@@ -38,6 +38,7 @@ public class InformationAccountValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_InformationAccount);
             addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
             addImdg.accept(IMDGDistributedNames.Map_AccountTypeDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary);
             addImdg.accept(IMDGDistributedNames.Map_Account);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("companyId",
@@ -59,6 +60,10 @@ public class InformationAccountValidationConfig {
                     DictionaryPresentRule.instance("accountType", InformationAccountNewRequest::getAccountType,
                             IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.class,
                             AccountError.RequiredFieldEmpty, AccountError.DictionaryNotFound, false),
+                    DictionaryPresentRule.instance("currency", InformationAccountNewRequest::getCurrency,
+                            IMDGDistributedNames.Map_CurrencyCodeDictionary, ServiceStatusDictionary.class,
+                            null, AccountError.DictionaryNotFound,false
+                    ),
                     new SameAccountValidationRule<>(AccountType.Info, InformationAccountNewRequest::getAccount)
             );
         };

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

@@ -21,7 +21,7 @@ class SameAccountValidationRule<R> implements IValidationRule<ImdgValidationCont
     final Function<R, String> accountGetter;
 
     public SameAccountValidationRule(AccountType accountType, Function<R, String> accountGetter) {
-        this.accountType = accountType.getKey(); // or req.getAccountType()
+        this.accountType = accountType.getKey();
         this.accountGetter = accountGetter;
         Objects.requireNonNull(accountGetter);
     }
@@ -32,9 +32,8 @@ class SameAccountValidationRule<R> implements IValidationRule<ImdgValidationCont
         Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
         ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
         ImdgPredicate query = pb.and(
-                pb.equals("account", accountGetter.apply(req)), // req.getAccount()
-//                pb.equals("accountType", accountType), имена всех счетов уникальны, вне зависимости от типа
-                pb.in("status", ServiceStatus.Active.getKey(), ServiceStatus.Reopened.getKey(), ServiceStatus.Appl.getKey())
+            pb.equals("account", accountGetter.apply(req)),
+            pb.in("status", ServiceStatus.Active.getKey(), ServiceStatus.Reopened.getKey(), ServiceStatus.Appl.getKey())
         );
         Account existAccount = accountImdg.getFirstObjectByPredicate(query);
         if (existAccount != null) {

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

@@ -0,0 +1,247 @@
+package ru.spcex.clearing.account.config.validation;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.apache.commons.lang3.StringUtils;
+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.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+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.registry.TradingClearingRegistryListNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListUpdateRequest;
+import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
+import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.CurrencyCode;
+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;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IEnumKey;
+import ru.spcex.platform.utils.validation.IValidationRule;
+import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+@Configuration
+public class TradingClearingRegistryListValidationConfig {
+
+    @Bean("tradingClearingRegistryListNewRequestValidator")
+    public Function<TradingClearingRegistryListNewRequest, IValidator> tradingClearingRegistryListNewRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return tradingClearingRegistryListUpdateRequest -> {
+            ImdgValidationContext<TradingClearingRegistryListNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(tradingClearingRegistryListUpdateRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistryList);
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
+            return new ValidatorImpl<>(context,
+                IdPresentRule.instance("tradingClearingRegistryId",
+                    TradingClearingRegistryListNewRequest::getTradingClearingRegistryId,
+                    IMDGDistributedNames.Map_TradingClearingRegistry,
+                    TradingClearingRegistry.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.TradingClearingRegistryNotFound,
+                    false),
+                new ExistAllAccountId<>("accountId",
+                    TradingClearingRegistryListNewRequest::getCurrencyAccountList,
+                    TradingClearingRegistryListNewRequest::getAccountId,
+                    TradingClearingRegistryListNewRequest::getTradingClearingRegistryId,
+                    false,
+                    null),
+                DictionaryPresentRule.instance("stauts",
+                    TradingClearingRegistryListNewRequest::getStatus,
+                    IMDGDistributedNames.Map_ServiceStatusDictionary,
+                    ServiceStatusDictionary.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.DictionaryNotFound,
+                    false),
+                NotAlreadyPresent.instance
+            );
+        };
+    }
+
+    @Bean("tradingClearingRegistryListUpdateRequestValidator")
+    public Function<TradingClearingRegistryListUpdateRequest, IValidator> tradingClearingRegistryListUpdateRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
+        return tradingClearingRegistryListUpdateRequest -> {
+            ImdgValidationContext<TradingClearingRegistryListUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(tradingClearingRegistryListUpdateRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistryList);
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
+            return new ValidatorImpl<ImdgValidationContext<TradingClearingRegistryListUpdateRequest>>(context,
+                IdPresentRule.instance2("id",
+                    TradingClearingRegistryListUpdateRequest::getId,
+                    IMDGDistributedNames.Map_TradingClearingRegistryList,
+                    TradingClearingRegistryList.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.RecordNotFound,
+                    true,
+                    (tcrList) -> {
+                        Long accountId = tcrList.getAccountId();
+                        if (accountId == null)
+                            return null;
+                        if (!IEnumKey.contains(context.getValidatedObject().getStatus(),
+                            ServiceStatus.Active, ServiceStatus.Reopened))
+                            return null;
+
+                        Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+                        ImdgPredicateBuilder pb = tradingClearingRegistryListImdg.predicateBuilder();
+                        ImdgPredicate query = pb.and(pb.equals("status", WorkflowStatus.Active.getKey()),
+                            pb.equals("accountId", accountId));
+                        query = pb.and(query, pb.not(pb.equals("id", tcrList.getId())));
+                        Collection<TradingClearingRegistryList> inOtherLists = tradingClearingRegistryListImdg.getCollectionObjectsByPredicate(query);
+                        if (!inOtherLists.isEmpty()) {
+                            Collection<Long> duplicateAccounts = inOtherLists.stream()
+                                .map(TradingClearingRegistryList::getAccountId)
+                                .filter(accountId::equals)
+                                .collect(Collectors.toSet());
+                            return new EnumMessage(AccountError.AccountForTradingClearingRegistryAlreadyUsed, duplicateAccounts, "accountId");
+                        }
+                        return null;
+                    }),
+                DictionaryPresentRule.instance("status",
+                    TradingClearingRegistryListUpdateRequest::getStatus,
+                    IMDGDistributedNames.Map_ServiceStatusDictionary,
+                    ServiceStatusDictionary.class,
+                    AccountError.RequiredFieldEmpty,
+                    AccountError.DictionaryNotFound,
+                    true)
+            );
+        };
+    }
+
+    public static class NotAlreadyPresent implements IValidationRule<ImdgValidationContext<TradingClearingRegistryListNewRequest>> {
+        private static final NotAlreadyPresent instance = new NotAlreadyPresent();
+
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<TradingClearingRegistryListNewRequest> ctx) {
+            TradingClearingRegistryListNewRequest tcrListReq = ctx.getValidatedObject();
+            Long accountId = tcrListReq.getAccountId();
+            Imdg<TradingClearingRegistryList> tcrListImdg = ctx.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+            ImdgPredicateBuilder pb = tcrListImdg.predicateBuilder();
+            Collection<TradingClearingRegistryList> tcrLists = tcrListImdg.getCollectionObjectsByPredicate(
+                pb.and(
+                    pb.equals("tradingClearingRegistryId", tcrListReq.getTradingClearingRegistryId()),
+                    pb.equals("status", WorkflowStatus.Active.getKey())
+                )
+            );
+            if (tcrLists.stream().anyMatch(tcrList -> Objects.equals(accountId, tcrList.getAccountId()))) {
+                return of(AccountError.AccountForTradingClearingRegistryAlreadyUsed, accountId);
+            }
+            return empty();
+        }
+
+        @Override
+        public String ruleName() {
+            return "TradingClearingRegistryList.AlreadyPresent";
+        }
+    }
+
+    public static class ExistAllAccountId<R> implements IValidationRule<ImdgValidationContext<R>> {
+        String fieldName;
+        Function<R, List<Long>> accountIdListGetter;
+        Function<R, Long> accountIdGetter;
+        Function<R, Long> tkrIdGetter;
+        boolean required;
+        Function<R, Long> idGetter;
+
+        public ExistAllAccountId(String fieldName,
+                                 Function<R, List<Long>> accountIdListGetter,
+                                 Function<R, Long> accountIdGetter,
+                                 Function<R, Long> tkrIdGetter,
+                                 boolean required, Function<R, Long> idGetter) {
+            this.fieldName = fieldName;
+            this.accountIdListGetter = accountIdListGetter;
+            this.accountIdGetter = accountIdGetter;
+            this.tkrIdGetter = tkrIdGetter;
+            this.required = required;
+            this.idGetter = idGetter;
+        }
+
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<R> context) {
+            R validatedObject = context.getValidatedObject();
+            List<Long> accounts = accountIdListGetter.apply(validatedObject);
+            if (accounts == null) {
+                accounts = new ArrayList<>();
+            }
+            Long singleAccountId = accountIdGetter.apply(validatedObject);
+            if (singleAccountId != null) {
+                accounts.add(singleAccountId);
+            }
+            if (accounts.isEmpty()) {
+                if (required)
+                    return of(AccountError.RequiredFieldEmpty, fieldName);
+                else
+                    return Optional.empty();
+            }
+            Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            {
+                for (Long accountId : accounts) {
+                    Account byIdObject = accountImdg.getSingleObjectByID(accountId);
+                    if (byIdObject == null)
+                        return of(AccountError.AccountNotFound, accountId, fieldName);
+                    if (!IEnumKey.contains(byIdObject.getAccountType(), AccountType.Clrn, AccountType.Info)) {
+                        return of(AccountError.AccountIsNotACurrency, accountId,
+                            fieldName, "expected: CLRN/INFO but is " + byIdObject.getAccountType());
+                    }
+                    if (CurrencyCode.isRub(byIdObject.getCurrency()) || StringUtils.isEmpty(byIdObject.getCurrency())) {
+                        return of(AccountError.AccountIsNotACurrency, accountId, fieldName);
+                    }
+                    Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+                    ImdgPredicateBuilder pb = tradingClearingRegistryListImdg.predicateBuilder();
+
+                    Collection<TradingClearingRegistryList> listWithAccountId = tradingClearingRegistryListImdg.getCollectionObjectsByPredicate(
+                        pb.and(
+                            pb.equals("accountId", accountId),
+                            pb.equals("status", WorkflowStatus.Active.getKey())
+                        ));
+                    if (!listWithAccountId.isEmpty()) {
+                        return of(AccountError.AccountForTradingClearingRegistryAlreadyUsed, byIdObject.getAccount(), fieldName);
+                    }
+                    Long tkrId = tkrIdGetter.apply(validatedObject);
+                    ImdgPredicate query = pb.and(
+                        pb.equals("tradingClearingRegistryId", tkrId),
+                        pb.equals("status", WorkflowStatus.Active.getKey()),
+                        pb.equals("currency", byIdObject.getCurrency()));
+                    if (idGetter != null) {
+                        Long id = idGetter.apply(validatedObject);
+                        if (id == null)
+                            return of(AccountError.RequiredFieldEmpty, "id");
+                        query = pb.and(query, pb.not(pb.equals("id", id)));
+                    }
+                    Collection<TradingClearingRegistryList> inOtherLists = tradingClearingRegistryListImdg.getCollectionObjectsByPredicate(query);
+                    if (!inOtherLists.isEmpty()) {
+                        return of(AccountError.CurrencyForTradingClearingRegistryListAlreadyUsed, byIdObject.getCurrency(), fieldName);
+                    }
+                }
+            }
+
+            return empty();
+        }
+
+        @Override
+        public String ruleName() {
+            return getClass().getSimpleName() + "{" + fieldName + "}";
+        }
+    }
+
+}

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

@@ -31,6 +31,7 @@ import ru.spcex.platform.utils.validation.ValidatorImpl;
 
 import java.util.Collection;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -77,33 +78,17 @@ public class TradingClearingRegistryValidationConfig {
                             AccountError.RequiredFieldEmpty,
                             moneyAccountId -> {
                                 Imdg<Account> accountImdg = context.obtainMap(
-                                        IMDGDistributedNames.Map_Account, Account.class
+                                    IMDGDistributedNames.Map_Account, Account.class
                                 );
                                 Account account = accountImdg.getSingleObjectByID(moneyAccountId);
                                 if (account == null) {
                                     return AccountError.AccountNotFound;
                                 } else {
                                     if (AccountType.Clrn.equalsByKey(account.getAccountType()) || AccountType.Info.equalsByKey(account.getAccountType())) {
-                                        // ok
                                     } else {
-                                        // неправильный тип
                                         return AccountError.AccountNotFound;
                                     }
                                 }
-//                                Imdg<ClearingAccount> clearingAccountImdg = context.obtainMap(
-//                                        IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class
-//                                );
-//                                ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByFieldValues(
-//                                        Map.of("accountId",moneyAccountId)
-//                                );
-//                                if (clearingAccount == null) {
-//                                    Imdg<InformationAccount> informationAccountImdg = context.obtainMap(
-//                                            IMDGDistributedNames.Map_InformationAccount, InformationAccount.class
-//                                    );
-//                                    InformationAccount infoAccount = informationAccountImdg.getSingleObjectByFieldValues(
-//                                            Map.of("accountId",moneyAccountId));
-//                                    if (infoAccount == null) return AccountError.AccountNotFound;
-//                                }
                                 return null;
                             }),
                     FieldRequiredRule.instance("depoAccountId",
@@ -140,11 +125,6 @@ public class TradingClearingRegistryValidationConfig {
             if (validatedObject.getMoneyAccountId() == null) {
                 return of(AccountError.RequiredFieldEmpty, "MoneyAccountId");
             }
-            //Map<String, Comparable<?>> query = new HashMap<>();
-//            query.put("moneyAccountId", validatedObject.getMoneyAccountId());
-//            if (validatedObject.getDepoAccountId() != null) {
-//                query.put("depoAccountId", validatedObject.getDepoAccountId());
-//            }
             ImdgPredicateBuilder pb = tcrMap.predicateBuilder();
             ImdgPredicate query = pb.equals("moneyAccountId", validatedObject.getMoneyAccountId());
             if (validatedObject.getDepoAccountId() != null) {
@@ -160,8 +140,44 @@ public class TradingClearingRegistryValidationConfig {
                 Account account = accountImdg.getSingleObjectByID(validatedObject.getMoneyAccountId());
                 if (account == null && validatedObject.getDepoAccountId() != null) account = accountImdg.getSingleObjectByID(validatedObject.getDepoAccountId());
                 return of(AccountError.AccountForTradingClearingRegistryAlreadyUsed, account.getAccount());
-//                String tcrIds = existTCR.stream().map(tcr -> String.valueOf(tcr.getId())).collect(Collectors.joining(";"));
-//                return of(AccountError.AccountForTradingClearingRegistryAlreadyUsed, tcrIds);
+            }
+        }
+    }
+
+    static class updateTCRDepoCheck implements IValidationRule<ImdgValidationContext<TradingClearingRegistryUpdateRequest>> {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<TradingClearingRegistryUpdateRequest> context) {
+            TradingClearingRegistryUpdateRequest validatedObject = context.getValidatedObject();
+            Long depoAccountId = validatedObject.getDepoAccountId();
+            if (depoAccountId == null)
+                return empty();
+            Imdg<DepoAccount> depoAccountImdg = context.obtainMap(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
+            DepoAccount depoAccount = depoAccountImdg.getFirstObjectByFieldValues(
+                Map.of("accountId", depoAccountId)
+            );
+            if (depoAccount == null)
+                return of(AccountError.AccountNotFound, depoAccountId);
+            Imdg<TradingClearingRegistry> tcrMap = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+            Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            Account account = accountImdg.getSingleObjectByID(validatedObject.getMoneyAccountId());
+            if (account == null) {
+                return of(AccountError.AccountNotFound, depoAccountId);
+            }
+            TradingClearingRegistry updateObject = tcrMap.getSingleObjectByID(validatedObject.getId());
+            if (!Objects.equals(account.getCompanyId(), updateObject.getCompanyId())) {
+                return of(AccountError.AccountNotFound, depoAccountId);
+            }
+            ImdgPredicateBuilder pb = tcrMap.predicateBuilder();
+            ImdgPredicate query = pb.and(pb.equals("depoAccountId", validatedObject.getDepoAccountId()),
+                pb.not(pb.equals("id", validatedObject.getId()))
+            );
+            Collection<TradingClearingRegistry> existTCR = tcrMap.getCollectionObjectsByPredicate(query);
+            if (existTCR.isEmpty()) {
+                return empty();
+            } else {
+                if (account == null && validatedObject.getDepoAccountId() != null)
+                    account = accountImdg.getSingleObjectByID(validatedObject.getDepoAccountId());
+                return of(AccountError.AccountForTradingClearingRegistryAlreadyUsed, account.getAccount());
             }
         }
     }
@@ -177,6 +193,8 @@ public class TradingClearingRegistryValidationConfig {
             Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
             addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
             addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_DepoAccount);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("id",
                             TradingClearingRegistryUpdateRequest::getId,
@@ -190,7 +208,9 @@ public class TradingClearingRegistryValidationConfig {
                             ServiceStatusDictionary.class,
                             AccountError.RequiredFieldEmpty,
                             AccountError.DictionaryNotFound,
-                            false)
+                            false),
+
+                    new updateTCRDepoCheck()
             );
         };
     }

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

@@ -1,14 +1,28 @@
 package ru.spcex.clearing.account.config.validation;
 
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import ru.clearing.classes.statics.data.account.*;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.AccountSymbols;
+import ru.clearing.classes.statics.data.account.BankAccount;
+import ru.clearing.classes.statics.data.account.ClearingAccount;
+import ru.clearing.classes.statics.data.account.ClientCode;
+import ru.clearing.classes.statics.data.account.DepoAccount;
+import ru.clearing.classes.statics.data.account.InformationAccount;
 import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.company.CompanySymbols;
+import ru.clearing.classes.statics.data.misc.Currency;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
-import ru.clearing.platform.dictionary.*;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+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;
@@ -16,10 +30,6 @@ import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.BiConsumer;
-
 @Configuration
 public class ValidationConfig {
 
@@ -42,8 +52,8 @@ public class ValidationConfig {
         addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class);
         addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
         addImdg.accept(IMDGDistributedNames.Map_AccountSymbols, AccountSymbols.class);
-
-        //for ClientCodeValidationConfig
+        addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+        addImdg.accept(IMDGDistributedNames.Map_Currency, Currency.class);
         addImdg.accept(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
 
         return imdg;

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

@@ -19,11 +19,18 @@ public enum AccountError implements IErrorEnumId {
     DepoAccountNotFound(5017L),
     MoneyAccountNotFound(5018L),
     ClearingCategoryNotFound(5019L),
-    ClearingCompanySymbolNotFound(5022L), // Для компании %s отсутствует клиринговый код».
+    ClearingCompanySymbolNotFound(5022L),
     AccountForTradingClearingRegistryAlreadyUsed(5023L),
     AccountFieldNotSet(5024L),
     AccountDepoTypeRequired(5025L),
+    AccountIsNotACurrency(5026L),
+    CompanyHasNotClearingMemberCategory(5027L),
+    TCR_NOT_FOUND_GTW(5028L),
+    ACCOUNT_NOT_FOUND_GTW(5029L),
+    COMPANY_NOT_FOUND_GTW(5030L),
+    CurrencyForTradingClearingRegistryListAlreadyUsed(5031L),
     TradingClearingRegistryNotFound(3022L),
+    CurrencyNotFound(1016L),
     ;
 
     private final Long id;

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/model/ClientCodeBusiness.java

@@ -0,0 +1,28 @@
+package ru.spcex.clearing.account.model;
+
+import java.util.List;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.spcex.platform.enumeration.Status;
+
+public class ClientCodeBusiness {
+    private Status code;
+    private Company company;
+    private Account moneyAccount;
+    private Account depoAccount;
+    private List<Account> currentAccounts;
+    private TradingClearingRegistry tradingClearingRegistry;
+    private Status status;
+
+    public ClientCodeBusiness(Status code,
+                              Company company, Account moneyAccount, Account depoAccount, List<Account> currentAccounts, TradingClearingRegistry tradingClearingRegistry, Status status) {
+        this.code = code;
+        this.company = company;
+        this.moneyAccount = moneyAccount;
+        this.depoAccount = depoAccount;
+        this.currentAccounts = currentAccounts;
+        this.tradingClearingRegistry = tradingClearingRegistry;
+        this.status = status;
+    }
+}

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/model/TradingClearingRegistryBusiness.java

@@ -0,0 +1,79 @@
+package ru.spcex.clearing.account.model;
+
+import java.util.Optional;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.DepoAccount;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.spcex.platform.enumeration.Status;
+import ru.spcex.platform.enumeration.TradingClearingRegistryType;
+
+public class TradingClearingRegistryBusiness {
+    private Company company;
+    private Account moneyAccount;
+    private Status status;
+    private Optional<DepoAccount> depoAccount;
+    private Optional<TradingClearingRegistryType> tradingClearingRegistryType;
+
+    private TradingClearingRegistryBusiness() {
+        this.depoAccount = Optional.empty();
+        this.tradingClearingRegistryType = Optional.empty();
+    }
+
+    public static TradingClearingRegistryBusiness builder() {
+        return new TradingClearingRegistryBusiness();
+    }
+
+    public TradingClearingRegistryBusiness company(Company company) {
+        this.company = company;
+        return this;
+    }
+
+    public TradingClearingRegistryBusiness moneyAccount(Account moneyAccount) {
+        this.moneyAccount = moneyAccount;
+        return this;
+    }
+
+    public TradingClearingRegistryBusiness depoAccount(DepoAccount depoAccount) {
+        this.depoAccount = Optional.of(depoAccount);
+        return this;
+    }
+
+    public TradingClearingRegistryBusiness status(Status status) {
+        this.status = status;
+        return this;
+    }
+    public TradingClearingRegistryBusiness tradingClearingRegistryType(TradingClearingRegistryType type) {
+        this.tradingClearingRegistryType = Optional.of(type);
+        return this;
+    }
+
+    public TradingClearingRegistryBusiness build() {
+        TradingClearingRegistryBusiness tradingClearingRegistryBusiness = new TradingClearingRegistryBusiness();
+        tradingClearingRegistryBusiness.company = this.company;
+        tradingClearingRegistryBusiness.status = this.status;
+        tradingClearingRegistryBusiness.depoAccount = this.depoAccount;
+        tradingClearingRegistryBusiness.moneyAccount = this.moneyAccount;
+        tradingClearingRegistryBusiness.tradingClearingRegistryType = this.tradingClearingRegistryType;
+        return tradingClearingRegistryBusiness;
+    }
+
+    public Company getCompany() {
+        return company;
+    }
+
+    public Account getMoneyAccount() {
+        return moneyAccount;
+    }
+
+    public Optional<DepoAccount> getDepoAccount() {
+        return depoAccount;
+    }
+
+    public Status getStatus() {
+        return status;
+    }
+
+    public Optional<TradingClearingRegistryType> getTradingClearingRegistryType() {
+        return tradingClearingRegistryType;
+    }
+}

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/model/ValidationResult.java

@@ -0,0 +1,12 @@
+package ru.spcex.clearing.account.model;
+
+import java.util.Optional;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidator;
+
+public record ValidationResult(IValidator validator, Optional<EnumMessage> error, Optional<String> errorMsg) {
+    public boolean isValid() {
+        return error.isEmpty();
+    }
+}
+

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

@@ -42,11 +42,6 @@ public class AccountHelper {
         this.messageResolver = messageResolver;
     }
 
-    /**
-     * Заполняет поля relationId и companyId из соответствующей записи Relation
-     *
-     * @param requestId Идентификатор запроса для вывода лога
-     */
     public RequestInfoUpdate fillAccountFromRelation(Account account, Long requestId, boolean checkClearingMemberCategory) {
         Long companyId = account.getCompanyId();
         Collection<Relation> relations;
@@ -73,7 +68,6 @@ public class AccountHelper {
             } else {
                 log.info("ClearingCategoryNotFound with clearingCategoryValue={} not implemented. Do not search Relation.", clearingCategoryValue);
                 return null;
-                //return makeError(requestId, AccountError.ClearingCategoryNotFound, companyId, clearingCategoryValue + " (case not implemented)");
             }
             finalRelationPredicate = relationPredicateBuilder.and(consumerIdPredicate, servicePredicate);
             relations = relationMap.getCollectionObjectsByPredicate(finalRelationPredicate);
@@ -83,7 +77,6 @@ public class AccountHelper {
         }
 
         if (relations.isEmpty()) {
-            //return makeError(requestId, AccountError.WrongFieldValue, "companyId", finalRelationPredicate.toString());
             log.info("Relation not found: {}", finalRelationPredicate.toString());
             return null;
         }

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

@@ -1,5 +1,9 @@
 package ru.spcex.clearing.account.service;
 
+import java.time.Instant;
+import java.util.Collection;
+import java.util.Map;
+import java.util.function.Function;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -14,6 +18,7 @@ import ru.clearing.classes.statics.data.account.DepoAccount;
 import ru.clearing.classes.statics.data.account.InformationAccount;
 import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
 import ru.clearing.classes.statics.data.company.relation.Relation;
+import ru.clearing.classes.statics.data.misc.Currency;
 import ru.spcex.clearing.account.errors.AccountError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
@@ -28,22 +33,20 @@ 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.*;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.CurrencyCode;
+import ru.spcex.platform.enumeration.DepoAccountType;
+import ru.spcex.platform.enumeration.Sender;
+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.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.imdg.validation.Stored;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
-import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.validation.IValidator;
 
-import java.time.Instant;
-import java.util.Collection;
-import java.util.Map;
-import java.util.function.Function;
-
 @Service
 public class AccountService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -51,6 +54,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
     private final Imdg<Account> accountMap;
     private final Imdg<ClearingMemberCategory> clearingMemberCategoryMap;
     private final Imdg<Relation> relationMap;
+    private final Imdg<Currency> currencyMap;
     private final KafkaSender kafkaSender;
     private final IMessageResolver messageResolver;
     private final UserRoleVerification userRoleVerification;
@@ -72,22 +76,25 @@ public class AccountService extends QueueConsumer implements InitializingBean {
                           AccountHelper accountHelper,
                           InformationAccountService informationAccountService,
                           @Qualifier("correspondentAccountNewRequestValidator")
-                                  Function<CorrespondentAccountNewRequest, IValidator> accountNewRequestValidator,
+                          Function<CorrespondentAccountNewRequest, IValidator> accountNewRequestValidator,
                           @Qualifier("correspondentAccountUpdateRequestValidator")
-                                  Function<CorrespondentAccountUpdateRequest, IValidator> accountUpdateRequestValidator,
+                          Function<CorrespondentAccountUpdateRequest, IValidator> accountUpdateRequestValidator,
                           @Qualifier("correspondentAccountBlockRequestValidator")
-                                  Function<CommonIdRequest, IValidator> accountBlockRequestValidator) {
+                          Function<CommonIdRequest, IValidator> accountBlockRequestValidator) {
         super(kafkaQueue, kafkaProducer);
         this.accountHelper = accountHelper;
         this.imdgProvider = imdgProvider;
         this.accountMap = imdgProvider.getImdg(
-                IMDGDistributedNames.Map_Account, Account.class
+            IMDGDistributedNames.Map_Account, Account.class
         );
         this.clearingMemberCategoryMap = imdgProvider.getImdg(
-                IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class
+            IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class
         );
         this.relationMap = imdgProvider.getImdg(
-                IMDGDistributedNames.Map_Relation, Relation.class
+            IMDGDistributedNames.Map_Relation, Relation.class
+        );
+        this.currencyMap = imdgProvider.getImdg(
+            IMDGDistributedNames.Map_Currency, Currency.class
         );
         this.kafkaSender = kafkaSender;
         this.messageResolver = messageResolver;
@@ -103,18 +110,18 @@ public class AccountService extends QueueConsumer implements InitializingBean {
     public void afterPropertiesSet() {
         imdgProvider.waitAvailable();
         callback(CorrespondentAccountNewRequest.class)
-                .setFunction(this::accountCorrespondentNew)
-                .forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_NEW, callbacks::put);
+            .setFunction(this::accountCorrespondentNew)
+            .forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_NEW, callbacks::put);
         callback(CorrespondentAccountUpdateRequest.class)
-                .setFunction(this::correspondentAccountUpdate)
-                .forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_UPDATE, callbacks::put);
+            .setFunction(this::correspondentAccountUpdate)
+            .forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_UPDATE, callbacks::put);
         callback(CommonIdRequest.class)
-                .setFunction(this::correspondentAccountBlock)
-                .forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_BLOCK, callbacks::put);
+            .setFunction(this::correspondentAccountBlock)
+            .forDestination(Consts.DESTINATION_CORRESPONDENT_ACCOUNT_BLOCK, callbacks::put);
 
         callback(AccountTerminationRequest.class)
-                .setFunction(this::accountTerminationForCompany)
-                .forDestination(Consts.ACCOUNT_TERMINATION, callbacks::put);
+            .setFunction(this::accountTerminationForCompany)
+            .forDestination(Consts.ACCOUNT_TERMINATION, callbacks::put);
         init();
     }
 
@@ -125,22 +132,27 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
-        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, accountNewRequestValidator);
+        IValidator validator = accountNewRequestValidator.apply(userRequest.getRequestPayload());
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, (r) -> validator);
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
         CorrespondentAccountNewRequest req = userRequest.getRequestPayload();
-
+        Currency currency = validator.getStored(Stored.currency);
+        String currencyCode = req.getCurrency() == null ? CurrencyCode.RUB.getKey() : req.getCurrency();
+        Long currencyCodeId = CurrencyCode.RUB.getKey().equals(currencyCode) ? 810 : currency.getId();
         Instant now = Instant.now();
         Account account = new Account();
         account.setCompanyId(req.getCompanyId());
         account.setAccount(req.getAccount());
         if (AccountType.Info.equalsByKey(req.getAccountType())) {
-            Long infoSequenceId = informationAccountService.accountNextId();
-            String accountValue = informationAccountService.generateInfoAccount(infoSequenceId);
+            Long infoSequenceId = informationAccountService.accountNextId(currencyCode, currencyCodeId);
+
+            String accountValue = informationAccountService.generateInfoAccount(currencyCodeId, infoSequenceId);
             log.trace("New info-account SequenceId={} account={}", infoSequenceId, accountValue);
             account.setAccount(accountValue);
         }
         account.setAccountType(req.getAccountType());
+        account.setCurrency(currencyCode);
         if (req.getStatus() == null) {
             account.setStatus(WorkflowStatus.Active.getKey());
             log.trace("Status not set in request. Use default: {}", account.getStatus());
@@ -155,10 +167,8 @@ public class AccountService extends QueueConsumer implements InitializingBean {
 
         Long newId = null;
         if (AccountType.Corr.equalsByKey(account.getAccountType())) {
-            // default, дополнительные таблицы не требуются
             newId = accountMap.insert(account);
         } else {
-            // Транзакцией
             ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
             imdgTransaction.beginTransaction();
             boolean txOk = false;
@@ -167,7 +177,6 @@ public class AccountService extends QueueConsumer implements InitializingBean {
                 newId = accountMap.insert(account);
 
                 if (AccountType.Corr.equalsByKey(account.getAccountType())) {
-                    // default, дополнительные таблицы не требуются
                 } else if (AccountType.Info.equalsByKey(account.getAccountType()))
                     makeInfoPart(imdgTransaction, account);
                 else if (AccountType.Depo.equalsByKey(account.getAccountType()))
@@ -197,11 +206,12 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         InformationAccount infoAcc = new InformationAccount();
         infoAcc.setAccountId(account.getId());
         Account firstAccountAntl = accountMap.getFirstObjectByFieldValues(Map.of(
-                "companyId", Sender.One.getId(),
-                "accountType", AccountType.Anlt.getKey()
+            "companyId", Sender.One.getId(),
+            "accountType", AccountType.Anlt.getKey(),
+            "currency", account.getCurrency()
         ));
         if (firstAccountAntl == null) {
-            log.warn("Can not find 1 ANTL account for fill information ClearingAccountId.");
+            log.warn("Can not find 1 ANTL {} account for fill information ClearingAccountId.", account.getCurrency());
         } else {
             infoAcc.setClearingAccountId(firstAccountAntl.getId());
         }
@@ -218,7 +228,6 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         if (account.getAccount() != null && account.getAccount().contains("BC")) {
             depoAcc.setDepoAccountType(DepoAccountType.C.getKey());
         } else {
-            //todo в реквесте нет поля depoAcc.setDepoAccountType(req.getDepoAccountType());
         }
         Long depoId = depoAccountMap.insert(depoAcc);
         log.debug("For account id={} make DepoAccount id={}", account.getId(), depoId);
@@ -286,7 +295,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         log.debug("AccountTerminationRequest received, id={}", userRequest.getId());
 
         RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
-        if (requestInfoUpdate != null) return requestInfoUpdate; // never - system
+        if (requestInfoUpdate != null) return requestInfoUpdate;
 
         AccountTerminationRequest req = userRequest.getRequestPayload();
         final Long companyId = req.getCompanyId();
@@ -298,7 +307,6 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         try {
             tx.beginTransaction();
             for (Account account : accounts) {
-                //Account account = accountMap.getSingleObjectByID(request.getId());
                 if (!ServiceStatus.Blocked.equalsByKey(account.getStatus())) {
                     account.setStatus(ServiceStatus.Blocked.getKey());
                     account.setUpdated(Instant.now());
@@ -317,7 +325,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
 
         Long reqId = kafkaSender.sendRequestToQueue(Consts.ACCOUNT_TERMINATION_STEP2, req);
         log.info("On termination request id={} send to next step {} new request id={}",
-                userRequest.getId(), Consts.ACCOUNT_TERMINATION_STEP2, reqId);
+            userRequest.getId(), Consts.ACCOUNT_TERMINATION_STEP2, reqId);
 
         log.debug("successfully processed, account termination");
         return null;
@@ -326,9 +334,9 @@ public class AccountService extends QueueConsumer implements InitializingBean {
     private RequestInfoUpdate makeError(Long reqId, AccountError accountError, Object... args) {
         String errMsg = messageResolver.resolve(new EnumMessage(accountError, args));
         return new RequestInfoUpdate()
-                .setId(reqId)
-                .setStatus(Status.Error)
-                .setMessage(errMsg);
+            .setId(reqId)
+            .setStatus(Status.Error)
+            .setMessage(errMsg);
     }
 
 }

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

@@ -109,6 +109,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
             account.setStatus(req.getStatus());
         }
         account.setCompanyId(req.getCompanyId());
+        account.setCurrency(req.getCurrency());
         account.setCreated(now);
         account.setUpdated(now);
         requestInfoUpdate = accountService.fillAccountFromRelation(account, userRequest.getId(), false);
@@ -136,6 +137,8 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
             bankAccount.setAccount(req.getAccount());
             bankAccount.setCompanyId(req.getCompanyId());
             bankAccount.setAccountId(accountId);
+            bankAccount.setSwiftCode(req.getSwiftCode());
+            bankAccount.setIntermediarySwiftCode(req.getIntermediarySwiftCode());
             bankAccountId = bankAccountMap.insert(bankAccount);
 
             txOk = true;
@@ -173,9 +176,12 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
         bankAccount.setTaxpayerIdentificationNumber(req.getTaxpayerIdentificationNumber());
         bankAccount.setTaxRegistrationReasonCode(req.getTaxRegistrationReasonCode());
         bankAccount.setAccount(req.getAccount());
+        bankAccount.setSwiftCode(req.getSwiftCode());
+        bankAccount.setIntermediarySwiftCode(req.getIntermediarySwiftCode());
 
         Account account = accountMap.getSingleObjectByID(bankAccount.getAccountId());
         account.setAccount(req.account);
+        account.setCurrency(req.getCurrency());
         account.setUpdated(Instant.now());
 
         ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
@@ -221,7 +227,6 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
         account.setUpdated(Instant.now());
 
         accountMap.update(account);
-        //без изменений bankAccountMap.update(bankAccount);
 
         log.debug("successfully block, existing bankAccount with id {}", bankAccount.getId());
         return null;

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

@@ -1,5 +1,13 @@
 package ru.spcex.clearing.account.service;
 
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
 import org.apache.commons.lang3.tuple.MutableTriple;
 import org.apache.commons.lang3.tuple.Triple;
 import org.apache.kafka.clients.consumer.Consumer;
@@ -10,14 +18,17 @@ import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.ClearingAccount;
 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.classes.statics.data.misc.Currency;
 import ru.clearing.classes.statics.data.misc.Notification;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.clearing.classes.statics.data.sdf.SDf52;
+import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary;
 import ru.clearing.platform.dictionary.ClearingCategoryDictionary;
 import ru.spcex.clearing.account.errors.AccountError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
@@ -38,7 +49,15 @@ import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
 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.*;
+import ru.spcex.platform.enumeration.AccountStatus;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.ClearingAccountType;
+import ru.spcex.platform.enumeration.NotificationStatus;
+import ru.spcex.platform.enumeration.ObjectType;
+import ru.spcex.platform.enumeration.Priority;
+import ru.spcex.platform.enumeration.SdfTable;
+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.ImdgProvider;
 import ru.spcex.platform.imdg.api.ImdgTransaction;
@@ -46,15 +65,12 @@ import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.utils.collection.Pair;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.enumeration.IErrorEnumId;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.text.TextUtil;
 import ru.spcex.platform.utils.validation.IValidator;
 
-import java.time.Instant;
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Function;
-
 
 @Service
 public class ClearingAccountService extends QueueConsumer implements InitializingBean {
@@ -70,6 +86,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
     private final Function<ClearingAccountUpdateRequest, IValidator> clearingAccountUpdateRequestValidator;
 
     private final Imdg<Account> accountImdg;
+    private final Imdg<Currency> currImdg;
     private final Imdg<ClearingAccount> clearingAccountImdg;
     private final Imdg<Company> companyImdg;
     private final Imdg<Relation> relationImdg;
@@ -77,6 +94,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
     private final Imdg<ClearingCategoryDictionary> clearingCategoryImdg;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
     private final Imdg<Notification> notificationImdg;
+    private final Imdg<ClearingAccountTypeDictionary> clearingAccountTypeDictionaryImdg;
 
     @Autowired
     public ClearingAccountService(Consumer<String, Object> kafkaQueue,
@@ -104,6 +122,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         this.clearingAccountUpdateRequestValidator = clearingAccountUpdateRequestValidator;
 
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        this.currImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
         this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.relationImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Relation, Relation.class);
@@ -111,6 +130,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         this.clearingCategoryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingCategoryDictionary, ClearingCategoryDictionary.class);
         this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
         this.notificationImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Notification, Notification.class);
+        this.clearingAccountTypeDictionaryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccountTypeDictionary, ClearingAccountTypeDictionary.class);
     }
 
     @Override
@@ -135,7 +155,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         init();
     }
 
-    public RequestInfoUpdate clearingAccountNew(BaseRequest<ClearingAccountNewRequest> userRequest) {
+    public synchronized RequestInfoUpdate clearingAccountNew(BaseRequest<ClearingAccountNewRequest> userRequest) {
         RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(
                 userRequest, clearingAccountNewRequestValidator
         );
@@ -187,10 +207,14 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
                 imdgTransaction.rollbackTransaction();
             }
         }
+
+        if (txOk && account != null) {
+            sendNotificationAccountNewRequest(account);
+        }
         return null;
     }
 
-    public RequestInfoUpdate clearingAccountUpdate(BaseRequest<ClearingAccountUpdateRequest> userRequest) {
+    public synchronized RequestInfoUpdate clearingAccountUpdate(BaseRequest<ClearingAccountUpdateRequest> userRequest) {
         RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(
                 userRequest, clearingAccountUpdateRequestValidator
         );
@@ -237,11 +261,12 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
     }
 
 
-    public RequestInfoUpdate accountNewSdf01(BaseRequest<AccountSdf01Request> userRequest) {
+    public synchronized RequestInfoUpdate accountNewSdf01(BaseRequest<AccountSdf01Request> userRequest) {
         log.debug("AccountSdf01Request received, id={}", userRequest.getId());
 
         AccountSdf01Request req = userRequest.getRequestPayload();
         List<AccountSdfToStatementRequestPart> accountToStatement = new ArrayList<>();
+        List<Account> accountsToNotification = new ArrayList<>();
 
         ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
         boolean txOk = false;
@@ -254,19 +279,39 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
             for (AccountSdfRequestPart accountReq : req.getAccounts()) {
                 Instant now = Instant.now();
                 Account account = new Account();
+                try {
+                    Long currencyId = Long.valueOf(accountReq.getAccount().substring(5, 8));
+                    Currency currency = currImdg.getSingleObjectByID(currencyId);
+                    account.setCurrency(currency.getCurrencyCode());
+                } catch (Throwable e) {
+                    AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
+                    responsePart.setSdfId(accountReq.getSdfId());
+                    responsePart.setErrorCode(AccountError.DictionaryNotFound.getId());
+                    responsePart.setErrorText("couldn't extract currency from '%s' account".formatted(accountReq.getAccount()));
+                    accountToStatement.add(responsePart);
+                    log.info("sdf.id={} companyId={} accountType={} couldn't find currency for account {}",
+                        accountReq.getSdfId(),
+                        accountReq.getCompanyId(),
+                        accountReq.getAccountType(),
+                        accountReq.getAccount());
+                    continue accountsLoop;
+                }
                 account.setAccount(accountReq.getAccount());
                 account.setAccountType(AccountType.Clrn.getKey());
                 account.setStatus(ServiceStatus.Active.getKey());
                 account.setCompanyId(accountReq.getCompanyId());
+                if (TextUtil.isEmpty(account.getCurrency())) {
+                    log.warn("Sdf52: Wrong accountValue=\"{}\" - can not parse for get currency", accountReq.getAccount());
+                }
                 account.setCreated(now);
                 account.setUpdated(now);
                 RequestInfoUpdate requestInfoUpdate = accountService.fillAccountFromRelation(account, userRequest.getId(), true);
                 if (requestInfoUpdate != null) {
-                    log.warn("Error fill new account from relation. {}", /*account.getId(),*/ requestInfoUpdate.getMessage());
+                    log.warn("Error fill new account from relation. {}", requestInfoUpdate.getMessage());
                     {
                         AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
                         responsePart.setSdfId(accountReq.getSdfId());
-                        responsePart.setErrorCode(AccountError.ClearingCategoryNotFound.getId()); // see accountService.fillAccountFromRelation
+                        responsePart.setErrorCode(AccountError.ClearingCategoryNotFound.getId());
                         responsePart.setErrorText(requestInfoUpdate.getMessage());
                         accountToStatement.add(responsePart);
                         continue accountsLoop;
@@ -289,6 +334,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
                 Long accountId = -1L;
                 ClearingAccount clearingAccount = null;
                 accountId = accountImdg.insert(account);
+                accountsToNotification.add(account);
 
                 clearingAccount = new ClearingAccount();
                 clearingAccount.setCompanyId(accountReq.getCompanyId());
@@ -317,11 +363,99 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
 
 
         sendStatementRequestBack(req.getGroupingSdf01Id(), req.getGroupingSdf02Id(), accountToStatement);
+
+        if (txOk) {
+            for (Account account : accountsToNotification)
+                sendNotificationAccountNewRequest(account);
+        }
         log.debug("successfully processed, grouping id={}, processed number={}", req.getGroupingSdf01Id(), accountToStatement.size());
 
         return null;
     }
 
+    private synchronized Account createSdf52Account(String accountValue, String acctType, Long companyId, Long userRequestId) {
+        {
+            boolean existClearingAccountTypeDictionary;
+            if (!StringUtils.hasText(acctType)) {
+                existClearingAccountTypeDictionary = false;
+            } else {
+                ClearingAccountTypeDictionary catd = clearingAccountTypeDictionaryImdg.getFirstObjectByFieldValues(
+                    Map.of("code", acctType));
+                existClearingAccountTypeDictionary = catd != null;
+            }
+            if (!existClearingAccountTypeDictionary) {
+                String errMsg = messageResolver.resolve(new EnumMessage(AccountError.DictionaryNotFound, acctType, clearingAccountTypeDictionaryImdg.getMapName()));
+                log.warn(errMsg);
+                return null;
+            }
+
+            ClearingMemberCategory companyAnyCMC = clearingMemberCategoryImdg.getFirstObjectByFieldValues(Map.of(
+                "companyId", companyId
+            ));
+            if (companyAnyCMC == null) {
+                String errMsg = messageResolver.resolve(new EnumMessage(AccountError.CompanyHasNotClearingMemberCategory, companyId));
+                log.warn(errMsg);
+            }
+        }
+
+        Instant now = Instant.now();
+        Account account = new Account();
+        account.setAccount(accountValue);
+        account.setAccountType(AccountType.Clrn.getKey());
+        account.setStatus(ServiceStatus.Active.getKey());
+        if (accountValue.length() >= 7) {
+            try {
+                Long currencyId = Long.valueOf(accountValue.substring(5, 8));
+                Currency currency = currImdg.getSingleObjectByID(currencyId);
+                account.setCurrency(currency.getCurrencyCode());
+            } catch (Throwable e) {
+                log.trace("When obtain currency from accountValue: {}", e.toString());
+            }
+        }
+        if (TextUtil.isEmpty(account.getCurrency())) {
+            log.warn("Sdf52: Wrong accountValue=\"{}\" - can not parse for get currency", accountValue);
+        }
+        account.setCompanyId(companyId);
+        account.setCreated(now);
+        account.setUpdated(now);
+        RequestInfoUpdate requestInfoUpdate = accountService.fillAccountFromRelation(account, userRequestId, true);
+        if (requestInfoUpdate != null) {
+            log.warn("Error fill new account from relation. {}", requestInfoUpdate.getMessage());
+            return null;
+        }
+
+        Account existAccount = accountImdg.getFirstObjectBySQL("account = '%s' and accountType='%s'"
+            .formatted(accountValue, AccountType.Clrn.getKey()));
+        if (existAccount != null) {
+            log.debug("Sdf52: Account {} already exists", accountValue);
+            if (companyId.equals(existAccount.getCompanyId())) {
+                return existAccount;
+            } else {
+                log.debug("Sdf52: Account {} already exists for other companyId={}, do not apply for companyId={}",
+                    accountValue, existAccount.getCompanyId(), companyId);
+                return null;
+            }
+        }
+
+        Long clearingAccountId = -1L;
+        Long accountId = -1L;
+        ClearingAccount clearingAccount = null;
+        accountId = accountImdg.insert(account);
+
+        clearingAccount = new ClearingAccount();
+        clearingAccount.setCompanyId(companyId);
+        clearingAccount.setAccountId(accountId);
+        ClearingAccountType caType = IEnumKey.getEnumByKey(ClearingAccountType.class, acctType);
+        if (caType == null) {
+            log.warn("Wrong ClearingAccountType=\"{}\" for account \"{}\"", acctType, accountValue);
+        }
+        clearingAccount.setClearingAccountType(acctType);
+        clearingAccountId = clearingAccountImdg.insert(clearingAccount);
+        log.debug("New account {}, clearingAccount {} was created.", accountId, clearingAccountId);
+
+        return account;
+    }
+
     public RequestInfoUpdate accountUpdateSdf52(BaseRequest<StatementRequest> systemRequest) {
         log.debug("accountUpdateSdf52 StatementRequest received, id={}", systemRequest.getId());
 
@@ -329,7 +463,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         Long groupId = req.getGroupId();
         if (SdfTable.SDF_52 != req.getTable()) {
             log.warn("Unsupported table {} received on accountUpdateSdf52. Expected only {}.",
-                    req.getTable(), SdfTable.SDF_52);
+                req.getTable(), SdfTable.SDF_52);
         }
         Collection<SDf52> sdfs = sdfProcessService.sdfsByGroupId(groupId);
         if (sdfs.isEmpty()) {
@@ -340,13 +474,13 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
 
         List<Pair<SDf52, Account>> toUpdate = new ArrayList<>();
         List<Triple<SDf52, Account, String>> toProcessSDF53 = new ArrayList<>();
-        { // 1. Выборка данных
+        {
             for (SDf52 sDf52 : sdfs) {
                 if (sdfProcessService.parseSdf52Status(sDf52.getStatus()) == null) {
                     String msg = messageResolver.resolve(new EnumMessage(AccountError.WrongFieldValue, "status"));
                     log.warn("By generationId={} s_df52[{}] error: {}", groupId, sDf52.getId(), msg);
                     toProcessSDF53.add(new MutableTriple<>(sDf52, null,
-                            makeSdfErrorText(AccountError.WrongFieldValue, SDFProcessService.SDF_STATUS_ERROR)));
+                        makeSdfErrorText(AccountError.WrongFieldValue, SDFProcessService.SDF_STATUS_ERROR)));
                     continue;
                 }
                 Company company = sDf52.getDeal() == null ? null : companyImdg.getSingleObjectByFieldValues(Map.of("tradingCode", sDf52.getDeal()));
@@ -354,52 +488,58 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
                     String msg = messageResolver.resolve(new EnumMessage(AccountError.CompanyNotFound, sDf52.getDeal()));
                     log.warn("By generationId={} s_df52[{}] error: {}", groupId, sDf52.getId(), msg);
                     toProcessSDF53.add(new MutableTriple<>(sDf52, null,
-                            makeSdfErrorText(AccountError.CompanyNotFound, SDFProcessService.SDF_STATUS_ERROR_COMPANY_NOT_FOUND)));
+                        makeSdfErrorText(AccountError.CompanyNotFound, SDFProcessService.SDF_STATUS_ERROR_COMPANY_NOT_FOUND)));
                     continue;
                 }
                 Map<String, Comparable<?>> accountQuery = Map.of(
-                        "accountType", AccountType.Clrn.getKey(),
-                        "account", sDf52.getAccount(),
-                        "companyId", company.getId()
+                    "accountType", AccountType.Clrn.getKey(),
+                    "account", sDf52.getAccount(),
+                    "companyId", company.getId()
                 );
                 Account account = sDf52.getAccount() == null ? null : accountImdg.getFirstObjectByFieldValues(accountQuery);
                 if (account == null) {
                     if (SDFProcessService.SDF52_STATUS_3Open.equals(sDf52.getStatus())) {
-                        log.debug("By generationId={} s_df52[{}].status={}, but account not found (query: {}). COntinuse with result OK for status 3",
-                                groupId, sDf52.getId(), sDf52.getStatus(), accountQuery);
+                        log.trace("By generationId={} s_df52[{}].status={}, account not found (query: {}). Try create new account.",
+                            groupId, sDf52.getId(), sDf52.getStatus(), accountQuery);
+                        account = createSdf52Account(sDf52.getAccount(), sDf52.getAcc_type(), company.getId(), systemRequest.getId());
+                        if (account == null) {
+                            log.info("Can not create account: \"{}\", companyId={}. Ignore SDF52.id={}",
+                                sDf52.getAccount(), company.getId(), sDf52.getId());
+                            continue;
+                        }
                     } else {
                         String msg = messageResolver.resolve(new EnumMessage(AccountError.AccountNotFound, sDf52.getAccount()));
                         log.warn("By generationId={} s_df52[{}] (query: {}) error: {}", groupId, sDf52.getId(), accountQuery, msg);
                         toProcessSDF53.add(new MutableTriple<>(sDf52, null,
-                                makeSdfErrorText(AccountError.AccountNotFound, SDFProcessService.SDF_STATUS_ERROR_COMPANY_NOT_FOUND)));
+                            makeSdfErrorText(AccountError.AccountNotFound, SDFProcessService.SDF_STATUS_ERROR_COMPANY_NOT_FOUND)));
                         continue;
                     }
                 }
                 toProcessSDF53.add(new MutableTriple<>(sDf52, account, SDFProcessService.SDF_STATUS_OK));
-                toUpdate.add(new Pair<>(sDf52, account));
+                if (account != null) {
+                    toUpdate.add(new Pair<>(sDf52, account));
+                }
             }
         }
         log.debug("Selected to update {} account's", toUpdate.size());
-
-        // 4. to notification
         List<Long> notificationAccountIds = new ArrayList<>();
         for (Pair<SDf52, Account> item : toUpdate) {
             SDf52 sdf = item.getFirst();
             Account account = item.getSecond();
             AccountStatus newStatus = sdfProcessService.parseSdf52Status(sdf.getStatus());
-            if (newStatus == null) { // never
+            if (newStatus == null) {
                 throw new IllegalArgumentException("Can not parse sdf status " + sdf.getStatus());
             }
             if (newStatus.equalsByKey(account.getStatus())) {
-                // одинаковых обычно не бывает.
+                log.trace("In sDF_52[{}] for account [{}] status {} not changed.", sdf.getId(), account.getId(), newStatus);
                 continue;
             }
-            if (AccountStatus.BLOCKED == newStatus || AccountStatus.CLOSE == newStatus) { // статус 0/2
+            if (AccountStatus.BLOCKED == newStatus || AccountStatus.CLOSE == newStatus) {
                 sendNotificationRequest(ObjectType.account_block, account, newStatus);
                 notificationAccountIds.add(account.getId());
                 putNotificationWaiting(systemRequest, item.getFirst(), item.getSecond());
             }
-            if (AccountStatus.ACTIVE == newStatus) { // статус 1/3
+            if (AccountStatus.ACTIVE == newStatus) {
                 sendNotificationRequest(ObjectType.account_active, account, newStatus);
                 notificationAccountIds.add(account.getId());
                 putNotificationWaiting(systemRequest, item.getFirst(), item.getSecond());
@@ -410,7 +550,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         log.info("{} account's need wait accept over notification. GroupId={}", notificationAccountIds.size(), groupId);
 
         log.debug("successfully processed, grouping id={} with {} accounts.",
-                groupId, toUpdate.size());
+            groupId, toUpdate.size());
         return null;
     }
 
@@ -435,35 +575,29 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         }
     }
 
-    protected RequestInfoUpdate accountUpdateSdf52_part2(BaseRequest<StatementRequest> systemRequest1,
-                                                         SDf52 sdf, Account account,
-                                                         BaseRequest<NotificationFeedbackRequest> secondSystemRequest2) {
-        // 5. from notification:
+    protected synchronized RequestInfoUpdate accountUpdateSdf52_part2(BaseRequest<StatementRequest> systemRequest1,
+                                                                      SDf52 sdf, Account account,
+                                                                      BaseRequest<NotificationFeedbackRequest> secondSystemRequest2) {
         StatementRequest req = systemRequest1.getRequestPayload();
         Long groupId = req.getGroupId();
         log.info("Continue Sdf52 groupId={}, first request id={}, second request id={}",
-                groupId, systemRequest1 == null ? null : systemRequest1.getId(), secondSystemRequest2 == null ? null : secondSystemRequest2.getId());
+            groupId, systemRequest1 == null ? null : systemRequest1.getId(), secondSystemRequest2 == null ? null : secondSystemRequest2.getId());
 
         int countOfUpdated = 0;
-
-        // 2. обновление данных
         Instant now = Instant.now();
         AccountStatus newStatus = sdfProcessService.parseSdf52Status(sdf.getStatus());
         if (newStatus == null) {
             throw new IllegalArgumentException("Can not parse sdf status " + sdf.getStatus());
         }
-        // За долгое время ожидания пользователя счёт мог быть обновлён, прочитать его ещё раз
         account = accountImdg.getSingleObjectByID(account.getId());
         if (!newStatus.equalsByKey(account.getStatus())) {
-            // Обновление счёта
             String oldStatus = account.getStatus();
             account.setStatus(newStatus.getKey());
             account.setUpdated(now);
             accountImdg.update(account);
             log.trace("S_DF52[{}] do update status to {} for account[{}]",
-                    sdf.getId(), newStatus.getKey(), account.getId());
-            if (AccountStatus.ACTIVE.equalsByKey(oldStatus) && AccountStatus.ACTIVE != newStatus) { // счёт заблокировали - значит блокируем ТКР, наоборот не надо.
-                // Отправка в ТКР
+                sdf.getId(), newStatus.getKey(), account.getId());
+            if (AccountStatus.ACTIVE.equalsByKey(oldStatus) && AccountStatus.ACTIVE != newStatus) {
                 TradingClearingRegistryUpdateRequest tcrReq = new TradingClearingRegistryUpdateRequest();
                 tcrReq.setMoneyAccountId(account.getId());
                 tcrReq.setCompanyId(account.getCompanyId());
@@ -488,7 +622,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         }
 
         log.debug("successfully processed, grouping id={}. Updated {} accounts.",
-                groupId, countOfUpdated);
+            groupId, countOfUpdated);
         return null;
     }
 
@@ -506,8 +640,9 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         request.setGroupId(groupingSdf01Id);
         request.setChildGenerationId(groupSdf02Id);
         request.setAccountCreationResults(results);
+        request.setFromAccount(true);
         request.setContinueSdf(true);
-        request.setTable(SdfTable.SDF_01); // по нему запрос получили
+        request.setTable(SdfTable.SDF_01);
         log.debug("Send message to kafka \"{}\": {}", destination, LogFormatter.toStringWrapper(request));
         kafkaSender.sendRequestToQueue(destination, request);
     }
@@ -531,7 +666,20 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
     }
 
 
-    // --------- notification apply system -----------
+    public Long sendNotificationAccountNewRequest(Account account) {
+        String message = String.format("Добавлен новый счет %s", account.getAccount());
+        final String destination = Consts.NOTIFICATION_NEW;
+        NotificationNewRequest request = new NotificationNewRequest();
+        request.setObjectType(ObjectType.rgst.getKey());
+        request.setPriority(Priority.HIGH.getKey());
+        request.setComment(message);
+        log.debug("Send message to kafka \"{}\": {}", destination, LogFormatter.toStringWrapper(request));
+        Long rKey = kafkaSender.sendRequestToQueue(destination, request);
+        log.trace("About account.id={} send notification request id={}", account.getId(), rKey);
+        return rKey;
+    }
+
+
     public static class SDF52WaitingData {
         public BaseRequest<StatementRequest> systemRequest;
         public SDf52 sdf;
@@ -565,9 +713,6 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         return true;
     }
 
-    /**
-     * @return triggered SDF52WaitingData or null
-     */
     public SDF52WaitingData onNotificationResponse(NotificationFeedbackRequest onNotification) {
         if (onNotification.getNotificationId() == null) {
             log.trace("notificationId was empty");

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

@@ -1,5 +1,14 @@
 package ru.spcex.clearing.account.service;
 
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.function.Function;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.apache.kafka.clients.producer.ProducerRecord;
@@ -9,8 +18,11 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.ClientCode;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.spcex.clearing.account.errors.AccountError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
@@ -19,13 +31,20 @@ import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeUpdateRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccount;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.MoneyAccountMsgRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.MoneyAccountMsgResponse;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.Tkr;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListUpdateRequest;
 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.serialization.LogFormatter;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
 import ru.spcex.clearing.platform.messaging.service.Status;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.clearing.util.security.UserRoleVerification;
 import ru.spcex.clearing.util.services.RequestHelper;
 import ru.spcex.clearing.validation.common.ValidationHelper;
@@ -39,13 +58,6 @@ import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.log.ExceptionUtils;
 import ru.spcex.platform.utils.validation.IValidator;
 
-import java.time.Instant;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.function.Function;
-
 @Service
 public class ClientCodeService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -54,86 +66,83 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
     private final ImdgProvider imdgProvider;
     private final Imdg<ClientCode> clientCodeMap;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryMap;
-
-
+    private final Imdg<CompanySymbols> companySymbolsImdg;
+    private final Imdg<Account> accountImdg;
     private final Function<ClientCodeNewRequest, IValidator> clientCodeNewRequestValidator;
     private final Function<ClientCodeUpdateRequest, IValidator> clientCodeUpdateRequestValidator;
     private final Function<CommonDeleteRequest, IValidator> clientCodeDeleteRequestValidator;
+    private final Function<TkrAccount, IValidator> tkrAccountsGatewayValidator;
     private final ValidationHelper validationHelper;
     private final UserRoleVerification userRoleVerification;
     private final IMessageResolver messageResolver;
     private final RequestHelper requestHelper;
 
     protected TradingClearingRegistryService tradingClearingRegistryService;
+    protected ConfigurableApplicationContext context;
+    private final KafkaSender kafkaSender;
 
     @Autowired
     public ClientCodeService(Consumer<String, Object> kafkaQueue,
                              Producer<String, Object> kafkaProducer,
+                             KafkaSender kafkaSender,
                              ImdgProvider imdgProvider,
                              ValidationHelper validationHelper,
                              IMessageResolver messageResolver,
                              RequestHelper requestHelper,
                              TradingClearingRegistryService tradingClearingRegistryService,
+                             ConfigurableApplicationContext context,
                              UserRoleVerification userRoleVerification,
                              @Qualifier("clientCodeNewRequestValidator") Function<ClientCodeNewRequest, IValidator> clientCodeNewRequestValidator,
                              @Qualifier("clientCodeUpdateRequestValidator") Function<ClientCodeUpdateRequest, IValidator> clientCodeUpdateRequestValidator,
-                             @Qualifier("clientCodeDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> clientCodeDeleteRequestValidator) {
+                             @Qualifier("clientCodeDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> clientCodeDeleteRequestValidator,
+                             @Qualifier("tkrAccountsGatewayValidator") Function<TkrAccount, IValidator> tkrAccountsGatewayValidator) {
         super(kafkaQueue, kafkaProducer);
         this.kafkaProducer = kafkaProducer;
+        this.kafkaSender = kafkaSender;
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.clientCodeMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
         this.tradingClearingRegistryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+        this.companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
+        this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.clientCodeNewRequestValidator = clientCodeNewRequestValidator;
         this.clientCodeUpdateRequestValidator = clientCodeUpdateRequestValidator;
         this.clientCodeDeleteRequestValidator = clientCodeDeleteRequestValidator;
+        this.tkrAccountsGatewayValidator = tkrAccountsGatewayValidator;
         this.validationHelper = validationHelper;
         this.requestHelper = requestHelper;
         this.messageResolver = messageResolver;
         this.userRoleVerification = userRoleVerification;
         this.tradingClearingRegistryService = tradingClearingRegistryService;
+        this.context = context;
     }
 
     @Override
     public void afterPropertiesSet() {
         imdgProvider.waitAvailable();
-
         callback(ClientCodeNewRequest.class)
-                .setFunction(this::clientCodeNew)
-                .forDestination(Consts.DESTINATION_CLIENT_CODE_NEW, callbacks::put);
-        callback(ClientCodeNewRequest.class)
-                .setFunction(this::clientCodeNewFromApiUmCompany)
-                .forDestination(Consts.DESTINATION_CLIENT_CODE_NEW_UM_COMPANY, callbacks::put);
+            .setFunction(this::clientCodeNewFromApiUmCompany)
+            .forDestination(Consts.DESTINATION_CLIENT_CODE_NEW_UM_COMPANY, callbacks::put);
 
         callback(ClientCodeUpdateRequest.class)
-                .setFunction(this::clientCodeUpdate)
-                .forDestination(Consts.DESTINATION_CLIENT_CODE_UPDATE, callbacks::put);
+            .setFunction(this::clientCodeUpdate)
+            .forDestination(Consts.DESTINATION_CLIENT_CODE_UPDATE, callbacks::put);
         callback(CommonDeleteRequest.class)
-                .setFunction(this::clientCodeDelete)
-                .forDestination(Consts.DESTINATION_CLIENT_CODE_DELETE, callbacks::put);
+            .setFunction(this::clientCodeDelete)
+            .forDestination(Consts.DESTINATION_CLIENT_CODE_DELETE, callbacks::put);
         init();
 
     }
 
-    /**
-     * Проверки
-     * 3.5.1  если не была найдена запись в tradingClearingRegistry по companyId, moneyAccountId, depoAccountId и tradingClearingRegistryType=B (п 3.5.1)
-     * 3.5.2 если не заполнены   поля moneyAccountId ИЛИ moneyAccountId и depoAccountId
-     * @param userRequest
-     * @param moneyAccountId  req.getMoneyAccountId()
-     * @param depoAccountId req.getDepoAccountId()
-     * @param companyId req.getCompanyId()
-     * @return
-     */
     RequestInfoUpdate crossValidate(BaseRequest<?> userRequest, Long moneyAccountId, Long depoAccountId, Long companyId) {
-        if (moneyAccountId == null) { // Если не заполнены moneyAccountId ИЛИ moneyAccountId и depoAccountId
+        if (moneyAccountId == null) {
             EnumMessage error = null;
             if (companyId == null) {
                 error = new EnumMessage(AccountError.RequiredFieldEmpty, "companyId");
             } else {
                 TradingClearingRegistry tcr = tradingClearingRegistryMap.getFirstObjectByFieldValues(Map.of("companyId", companyId));
-                if (tcr==null) {
-                    error=new EnumMessage(AccountError.TradingClearingRegistryNotFound, companyId);
+                if (tcr == null) {
+                    error = new EnumMessage(AccountError.TradingClearingRegistryNotFound, companyId);
                 }
             }
             if (error != null) {
@@ -143,7 +152,7 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         return null;
     }
 
-    protected RequestInfoUpdate clientCodeNew(BaseRequest<ClientCodeNewRequest> userRequest) {
+    protected RequestInfoUpdate clientCodeNew0(BaseRequest<ClientCodeNewRequest> userRequest, boolean fromTCRList) {
         log.debug("ClientCodeNewRequest received {}", userRequest.getId());
 
         RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
@@ -153,7 +162,6 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
         ClientCodeNewRequest req = userRequest.getRequestPayload();
-        // дополнительная проверка
         requestInfoUpdate = crossValidate(userRequest, req.getMoneyAccountId(), req.getDepoAccountId(), req.getCompanyId());
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
@@ -161,25 +169,66 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         if (doCreateTCR) {
             try {
                 requestInfoUpdate = createAndWaitTCR(userRequest.getId(), null,
-                        req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
+                    req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
                 if (requestInfoUpdate != null) return requestInfoUpdate;
             } catch (Exception e) {
                 log.error("Can not wait creation of TCR. request id={};CompanyId={}, MoneyAccountId={}, DepoAccountId={}; {}",
-                        userRequest.getId(), req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId(),
-                        e.toString());
+                    userRequest.getId(), req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId(),
+                    e.toString());
                 return makeErrorResponse(userRequest, AccountError.GeneralError, "Can not create TCR: " + e.getMessage());
             }
         }
 
-        ClientCode newClientCode = buildClientCode(req);
-        clientCodeMap.insert(newClientCode);
-        log.debug("successfully processed, new clientCode id {}", newClientCode.getId());
+        if (req.getCurrencyAccountList() == null || req.getCurrencyAccountList().isEmpty()) {
+            ClientCode newClientCode = buildClientCode(req);
+            clientCodeMap.insert(newClientCode);
+            log.debug("successfully processed, new clientCode id {}", newClientCode.getId());
+        } else {
+            if (!fromTCRList) {
+                if (req.getMoneyAccountId() != null) {
+                    TradingClearingRegistry tcr = selectTradingClearingRegistry(req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
+
+                    TradingClearingRegistryListNewRequest tcrListNewR = new TradingClearingRegistryListNewRequest();
+                    tcrListNewR.setTradingClearingRegistryId(tcr == null ? null : tcr.getId());
+                    tcrListNewR.setCurrencyAccountList(req.getCurrencyAccountList());
+                    tcrListNewR.setStatus(req.getStatus());
+
+                    TradingClearingRegistryListService tradingClearingRegistryListService = context.getBean(TradingClearingRegistryListService.class);
+
+                    try {
+                        BaseRequest<TradingClearingRegistryListNewRequest> request2 = new BaseRequest<>();
+                        request2.setId(idGenerator.nextId());
+                        request2.setActionType(ActionType.NEW);
+                        request2.setRequestPayload(tcrListNewR);
+                        requestInfoUpdate = tradingClearingRegistryListService.tradingClearingRegistryListNew0(request2, true);
+                        if (requestInfoUpdate != null) return requestInfoUpdate;
+                    } catch (Exception e) {
+                        log.error("Can not wait creation of tradingClearingRegistryList. request id={}; {}",
+                            userRequest.getId(),
+                            ExceptionUtils.getStackTrace(e));
+                        return makeErrorResponse(userRequest, AccountError.GeneralError, "Can not create TCR: " + e.getMessage());
+                    }
+                }
+            }
+            List<Long> newClientCodeIds = new ArrayList<>();
+            for (Long currencyAccountId : req.getCurrencyAccountList()) {
+                ClientCode newClientCode = buildClientCode(req);
+                newClientCode.setCurrencyAccountId(currencyAccountId);
+                clientCodeMap.insert(newClientCode);
+                newClientCodeIds.add(newClientCode.getId());
+                log.trace("ClientCode.id={} for currencyAccountId={} created", newClientCode.getId(), currencyAccountId);
+            }
+            log.debug("successfully processed, new clientCode id {}", newClientCodeIds);
+        }
 
         return null;
     }
 
-
     protected RequestInfoUpdate clientCodeNewFromApiUmCompany(BaseRequest<ClientCodeNewRequest> userRequest) {
+        return clientCodeNewFromApiUmCompany0(userRequest, false);
+    }
+
+    protected RequestInfoUpdate clientCodeNewFromApiUmCompany0(BaseRequest<ClientCodeNewRequest> userRequest, boolean fromTCRList) {
         log.debug("ClientCodeNewRequest (UM_COMPANY) received {}", userRequest.getId());
 
         RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
@@ -190,7 +239,6 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
 
 
         ClientCodeNewRequest req = userRequest.getRequestPayload();
-        // дополнительная проверка
         requestInfoUpdate = crossValidate(userRequest, req.getMoneyAccountId(), req.getDepoAccountId(), req.getCompanyId());
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
@@ -198,19 +246,56 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         if (doCreateTCR) {
             try {
                 requestInfoUpdate = createAndWaitTCR(userRequest.getId(), null,
-                        req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
+                    req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
                 if (requestInfoUpdate != null) return requestInfoUpdate;
             } catch (Exception e) {
                 log.error("Can not wait creation of TCR. request id={};CompanyId={}, MoneyAccountId={}, DepoAccountId={}; {}",
-                        userRequest.getId(), req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId(),
-                        e.toString());
+                    userRequest.getId(), req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId(),
+                    e.toString());
                 return makeErrorResponse(userRequest, AccountError.GeneralError, "Can not create TCR at this moment" + e.getMessage());
             }
         }
 
-        ClientCode newClientCode = buildClientCode(req);
-        clientCodeMap.insert(newClientCode);
-        log.debug("successfully processed, new clientCode id {}", newClientCode.getId());
+        if (req.getCurrencyAccountList() == null || req.getCurrencyAccountList().isEmpty()) {
+            ClientCode newClientCode = buildClientCode(req);
+            clientCodeMap.insert(newClientCode);
+            log.debug("successfully processed, new clientCode id {}", newClientCode.getId());
+        } else {
+            if (!fromTCRList) {
+                if (req.getMoneyAccountId() != null) {
+                    TradingClearingRegistry tcr = selectTradingClearingRegistry(req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
+
+                    TradingClearingRegistryListUpdateRequest tcrListUpdateR = new TradingClearingRegistryListUpdateRequest();
+                    tcrListUpdateR.setTradingClearingRegistryId(tcr == null ? null : tcr.getId());
+                    tcrListUpdateR.setCurrencyAccountList(req.getCurrencyAccountList());
+
+                    TradingClearingRegistryListService tradingClearingRegistryListService = context.getBean(TradingClearingRegistryListService.class);
+
+                    try {
+                        BaseRequest<TradingClearingRegistryListUpdateRequest> request2 = new BaseRequest<>();
+                        request2.setId(idGenerator.nextId());
+                        request2.setActionType(ActionType.NEW);
+                        request2.setRequestPayload(tcrListUpdateR);
+                        requestInfoUpdate = tradingClearingRegistryListService.tradingClearingRegistryListUpdate0(request2, true);
+                        if (requestInfoUpdate != null) return requestInfoUpdate;
+                    } catch (Exception e) {
+                        log.error("Can not wait creation of tradingClearingRegistryList. request id={}; {}",
+                            userRequest.getId(),
+                            ExceptionUtils.getStackTrace(e));
+                        return makeErrorResponse(userRequest, AccountError.GeneralError, "Can not create TCR: " + e.getMessage());
+                    }
+                }
+            }
+            List<Long> newClientCodeIds = new ArrayList<>();
+            for (Long currencyAccountId : req.getCurrencyAccountList()) {
+                ClientCode newClientCode = buildClientCode(req);
+                newClientCode.setCurrencyAccountId(currencyAccountId);
+                clientCodeMap.insert(newClientCode);
+                newClientCodeIds.add(newClientCode.getId());
+                log.trace("ClientCode.id={} for currencyAccountId={} created", newClientCode.getId(), currencyAccountId);
+            }
+            log.debug("successfully processed, new clientCode id {}", newClientCodeIds);
+        }
 
         return null;
     }
@@ -224,7 +309,6 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
 
         requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, clientCodeUpdateRequestValidator);
         if (requestInfoUpdate != null) return requestInfoUpdate;
-        // дополнительная проверка
         requestInfoUpdate = crossValidate(userRequest, req.getMoneyAccountId(), req.getDepoAccountId(), req.getCompanyId());
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
@@ -239,12 +323,12 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         if (doCreateTCR) {
             try {
                 requestInfoUpdate = createAndWaitTCR(userRequest.getId(), clientCode.getId(),
-                        req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
+                    req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
                 if (requestInfoUpdate != null) return requestInfoUpdate;
             } catch (Exception e) {
                 log.error("Can not wait creation of TCR. request id={};CompanyId={}, MoneyAccountId={}, DepoAccountId={}; {}",
-                        userRequest.getId(), req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId(),
-                        e.toString());
+                    userRequest.getId(), req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId(),
+                    e.toString());
                 return makeErrorResponse(userRequest, AccountError.GeneralError, "Can not create TCR: " + e.getMessage());
             }
         }
@@ -283,7 +367,7 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         return null;
     }
 
-    TradingClearingRegistry selectTradingClearingRegistry(Long companyId, Long moneyAccountId, Long depoAccountId) {
+    protected TradingClearingRegistry selectTradingClearingRegistry(Long companyId, Long moneyAccountId, Long depoAccountId) {
         Map<String, Comparable<?>> query = new HashMap<>();
         query.put("companyId", companyId);
         query.put("moneyAccountId", moneyAccountId);
@@ -292,12 +376,11 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
             query.put("depoAccountId", depoAccountId);
         }
         TradingClearingRegistry result = tradingClearingRegistryMap.getFirstObjectByFieldValues(query);
-        log.trace("TradingClearingRegistry by: {}; {}found", query, result == null ? "not " : "");
+        log.trace("TradingClearingRegistry by: {}; {} found", query, result == null ? "not" : "");
         return result;
     }
 
     private boolean checkNeedCreateTCR(Long companyId, Long moneyAccountId, Long depoAccountId) {
-        // moneyAccountId обязателен, depoAccountId опционален
         if (moneyAccountId == null) {
             return false;
         }
@@ -310,10 +393,10 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
     }
 
     protected RequestInfoUpdate createAndWaitTCR(Long reqId, Long clientCode,
-                                    Long companyId, Long moneyAccountId, Long depoAccountId) {
+                                                 Long companyId, Long moneyAccountId, Long depoAccountId) {
         log.debug("For request {}, clientCode={} need create TCR: companyId={}, moneyAccountId={}, depoAccountId={}",
-                reqId, clientCode == null ? "new" : clientCode,
-                companyId, moneyAccountId, depoAccountId);
+            reqId, clientCode == null ? "new" : clientCode,
+            companyId, moneyAccountId, depoAccountId);
         BaseRequest<TradingClearingRegistryNewRequest> request = new BaseRequest<>();
         request.setId(idGenerator.nextId());
         request.setActionType(ActionType.NEW);
@@ -321,11 +404,8 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         requestPayload.setCompanyId(companyId);
         requestPayload.setMoneyAccountId(moneyAccountId);
         requestPayload.setDepoAccountId(depoAccountId);
-//        requestPayload.setStatus(WorkflowStatus.Active.getKey());
         requestPayload.setTradingClearingRegistryType(TradingClearingRegistryType.Client_B.getKey());
         request.setRequestPayload(requestPayload);
-
-        // Следующий вызываемый метод обязательно должен быть synchronized.
         RequestInfoUpdate reply = tradingClearingRegistryService.tradingClearingRegistryNew(request);
         if (reply != null && Status.Error.equals(reply.getStatus())) {
             log.warn("tradingClearingRegistryService return error: " + reply.getMessage());
@@ -355,11 +435,6 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
     }
 
 
-    /**
-     * @param queue   Consts.*
-     * @param message BaseRequest
-     * @return
-     */
     private Long sendMessage(String queue, BaseRequest<?> message) {
         Long sentRequestId = message.getId();
         if (sentRequestId == null) {
@@ -383,13 +458,8 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         return null;
     }
 
-    /**
-     * @param req требуется заполнить tradingClearingRegistryId по tradingClearingRegistry.code
-     * @return
-     */
     private ClientCode buildClientCode(ClientCodeNewRequest req) {
         ClientCode clientCode = new ClientCode();
-//        clientCode.setId(idSequence.newId()); add in insert
         clientCode.setCreated(Instant.now());
         clientCode.setUpdated(clientCode.getCreated());
 
@@ -400,7 +470,7 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
             TradingClearingRegistry tradingClearingRegistry = selectTradingClearingRegistry(req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
             if (tradingClearingRegistry == null) {
                 log.warn("TCR not found: CompanyId {}, MoneyAccountId {}, DepoAccountId {}",
-                        req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
+                    req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
             } else {
                 clientCode.setTradingClearingRegistryId(tradingClearingRegistry.getId());
             }
@@ -423,7 +493,7 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
             TradingClearingRegistry tradingClearingRegistry = selectTradingClearingRegistry(req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
             if (tradingClearingRegistry == null) {
                 log.warn("TCR not found: CompanyId {}, MoneyAccountId {}, DepoAccountId {}",
-                        req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
+                    req.getCompanyId(), req.getMoneyAccountId(), req.getDepoAccountId());
             } else {
                 clientCode.setTradingClearingRegistryId(tradingClearingRegistry.getId());
             }
@@ -437,4 +507,21 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
         clientCode.setUpdated(Instant.now());
     }
 
+
+    private Tkr crateErrorTkrToGateway(TkrAccount tkrAccount, Optional<String> errorMsg) {
+        Tkr tkr = new Tkr();
+        tkr.setTkrCode(tkrAccount.getTkrCode());
+        tkr.setClientCode(tkrAccount.getClientCode());
+        tkr.setCompanyId(tkrAccount.getCompanyId());
+        tkr.setDepoAccount(tkrAccount.getDepoAccount());
+        errorMsg.ifPresent(tkr::setErrorMessage);
+        return tkr;
+    }
+
+    private MoneyAccountMsgResponse convertAccountToResponse(MoneyAccountMsgRequest moneyAccountMsgRequest) {
+        MoneyAccountMsgResponse msgResponse = new MoneyAccountMsgResponse();
+        msgResponse.setAccount(moneyAccountMsgRequest.getAccount());
+        msgResponse.setCurrCode(moneyAccountMsgRequest.getCurrCode());
+        return msgResponse;
+    }
 }

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

@@ -1,5 +1,9 @@
 package ru.spcex.clearing.account.service;
 
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -18,22 +22,24 @@ 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.utilities.NotificationNewRequest;
 import ru.spcex.clearing.platform.messaging.serialization.LogFormatter;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.clearing.validation.common.ValidationHelper;
-import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.DepoAccountType;
+import ru.spcex.platform.enumeration.ObjectType;
+import ru.spcex.platform.enumeration.Priority;
+import ru.spcex.platform.enumeration.SdfTable;
+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.ImdgProvider;
 import ru.spcex.platform.imdg.api.ImdgTransaction;
 import ru.spcex.platform.utils.validation.IValidator;
 
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Function;
-
 @Service
 public class DepoAccountService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -129,6 +135,9 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
                 imdgTransaction.rollbackTransaction();
             }
         }
+        if (txOk && depoAccount != null) {
+            sendNotificationAccountNewRequest(account);
+        }
         return null;
     }
 
@@ -137,6 +146,7 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
 
         AccountSdf01Request req = userRequest.getRequestPayload();
         List<AccountSdfToStatementRequestPart> accountToStatement = new ArrayList<>();
+        List<Account> accountsToNotification = new ArrayList<>();
 
         ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
         boolean txOk = false;
@@ -147,8 +157,6 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
             accountsLoop:
             for (AccountSdfRequestPart accountReq : req.getAccounts()) {
 
-//                DepoAccountNewRequest req = userRequest.getRequestPayload();
-
                 Instant now = Instant.now();
                 Account account = new Account();
                 account.setAccount(accountReq.getAccount());
@@ -159,11 +167,11 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
                 account.setUpdated(now);
                 RequestInfoUpdate requestInfoUpdate = accountService.fillAccountFromRelation(account, userRequest.getId(), true);
                 if (requestInfoUpdate != null) {
-                    log.warn("Error fill new account from relation. {}", /*account.getId(),*/ requestInfoUpdate.getMessage());
+                    log.warn("Error fill new account from relation. {}", requestInfoUpdate.getMessage());
                     {
                         AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
                         responsePart.setSdfId(accountReq.getSdfId());
-                        responsePart.setErrorCode(AccountError.ClearingCategoryNotFound.getId()); // see accountService.fillAccountFromRelation
+                        responsePart.setErrorCode(AccountError.ClearingCategoryNotFound.getId());
                         responsePart.setErrorText(requestInfoUpdate.getMessage());
                         accountToStatement.add(responsePart);
                         continue accountsLoop;
@@ -184,7 +192,8 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
                 Long depoAccountId = -1L;
                 Long accountId = -1L;
 
-                    accountId = accountImdg.insert(account);
+                accountId = accountImdg.insert(account);
+                accountsToNotification.add(account);
 
                 DepoAccount depoAccount = new DepoAccount();
                 depoAccount.setCompanyId(accountReq.getCompanyId());
@@ -197,7 +206,6 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
                 depoAccountId = depoAccountImdg.insert(depoAccount);
 
 
-
                 log.debug("New account {}, depoAccount {} was created.", accountId, depoAccountId);
 
                 {
@@ -219,6 +227,11 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
         }
 
         sendStatementRequestBack(req.getGroupingSdf01Id(), req.getGroupingSdf02Id(), accountToStatement);
+
+        if (txOk) {
+            for (Account account : accountsToNotification)
+                sendNotificationAccountNewRequest(account);
+        }
         log.debug("successfully processed, grouping id={}, processed number={}", req.getGroupingSdf01Id(), accountToStatement.size());
 
         return null;
@@ -228,10 +241,24 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
         StatementRequest request = new StatementRequest();
         request.setGroupId(groupingSdf01Id);
         request.setChildGenerationId(groupingSdf02Id);
-        request.setContinueSdf(true); //fixme????
+        request.setContinueSdf(true);
         request.setAccountCreationResults(results);
-        request.setTable(SdfTable.SDF_08); // по нему запрос получили
+        request.setFromAccount(true);
+        request.setTable(SdfTable.SDF_08);
         log.debug("Send message to kafka \"{}\": {}", Consts.STATEMENT_PROCESS, LogFormatter.toStringWrapper(request));
         kafkaSender.sendRequestToQueue(Consts.STATEMENT_PROCESS, request);
     }
+
+    public Long sendNotificationAccountNewRequest(Account account) {
+        String message = String.format("Добавлен новый счет %s", account.getAccount());
+        final String destination = Consts.NOTIFICATION_NEW;
+        NotificationNewRequest request = new NotificationNewRequest();
+        request.setObjectType(ObjectType.rgst.getKey());
+        request.setPriority(Priority.HIGH.getKey());
+        request.setComment(message);
+        log.debug("Send message to kafka \"{}\": {}", destination, LogFormatter.toStringWrapper(request));
+        Long rKey = kafkaSender.sendRequestToQueue(destination, request);
+        log.trace("About account.id={} send notification request id={}", account.getId(), rKey);
+        return rKey;
+    }
 }

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

@@ -16,7 +16,6 @@ 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.domain.cud.reports.NotificationRequest;
 import ru.spcex.clearing.platform.messaging.serialization.LogFormatter;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
@@ -26,6 +25,7 @@ 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.CurrencyCode;
 import ru.spcex.platform.enumeration.ServiceStatus;
 import ru.spcex.platform.enumeration.WorkflowStatus;
 import ru.spcex.platform.imdg.api.Imdg;
@@ -40,6 +40,7 @@ import ru.spcex.platform.utils.validation.IValidator;
 
 import java.time.Instant;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Function;
@@ -59,11 +60,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali
     private final Function<InformationAccountNewRequest, IValidator> infoAccountNewRequestValidator;
     private final Imdg<InformationAccount> informationAccountImdg;
     private final Imdg<Account> accountImdg;
-    /**
-     * Кэш-счётчик сквозных номеров счетов.
-     * См. accountNextId()
-     */
-    protected AtomicLong infoCounter;
+    protected Map<String, AtomicLong> infoCounterByCurrency = new HashMap<>();
 
     @Autowired
     public InformationAccountService(Consumer<String, Object> kafkaQueue,
@@ -76,7 +73,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali
                                      AccountHelper accountHelper,
                                      RequestHelper requestHelper,
                                      @Qualifier("informationAccountNewRequestValidator")
-                                             Function<InformationAccountNewRequest, IValidator> infoAccountNewRequestValidator) {
+                                     Function<InformationAccountNewRequest, IValidator> infoAccountNewRequestValidator) {
         super(kafkaQueue, kafkaResponseQueue);
         this.kafkaSender = kafkaSender;
         this.messageResolver = messageResolver;
@@ -87,21 +84,21 @@ public class InformationAccountService extends QueueConsumer implements Initiali
         this.requestHelper = requestHelper;
         this.infoAccountNewRequestValidator = infoAccountNewRequestValidator;
         this.informationAccountImdg = imdgProvider.getImdg(
-                IMDGDistributedNames.Map_InformationAccount, InformationAccount.class
+            IMDGDistributedNames.Map_InformationAccount, InformationAccount.class
         );
         this.accountImdg = imdgProvider.getImdg(
-                IMDGDistributedNames.Map_Account, Account.class
+            IMDGDistributedNames.Map_Account, Account.class
         );
     }
 
     @Override
     public void afterPropertiesSet() throws Exception {
         callback(InformationAccountNewRequest.class)
-                .setFunction(this::informationAccountNew)
-                .forDestination(Consts.DESTINATION_INFORMATION_ACCOUNT_NEW, callbacks::put);
+            .setFunction(this::informationAccountNew)
+            .forDestination(Consts.DESTINATION_INFORMATION_ACCOUNT_NEW, callbacks::put);
         callback(InformationAccountNewRequest.class)
-                .setFunction(this::informationAccountSystemNew)
-                .forDestination(Consts.INFORMATION_ACCOUNT_SYSTEM_NEW, callbacks::put);
+            .setFunction(this::informationAccountSystemNew)
+            .forDestination(Consts.INFORMATION_ACCOUNT_SYSTEM_NEW, callbacks::put);
         init();
     }
 
@@ -115,15 +112,17 @@ public class InformationAccountService extends QueueConsumer implements Initiali
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
         InformationAccountNewRequest req = userRequest.getRequestPayload();
+        String currency = req.getCurrency() == null ? CurrencyCode.RUB.getKey() : req.getCurrency();
 
         Long newId = informationAccountImdg.nextIDSequenceFor();
-        Long infoSequenceId = accountNextId();
-        String accountValue = generateInfoAccount(infoSequenceId);
+        Long infoSequenceId = accountNextId(currency, 810L);
+        String accountValue = generateInfoAccount(810L, infoSequenceId);
         log.trace("New info-account id={}, sequenceId={}, account={}", newId, infoSequenceId, accountValue);
 
         ImdgPredicateBuilder accountPredicateBuilder = accountImdg.predicateBuilder();
         ImdgPredicate companyIdPredicate = accountPredicateBuilder.equals("companyId", 1L);
-        ImdgPredicate accountTypePredicate = accountPredicateBuilder.equals("accountType", AccountType.Anlt.getKey());
+        ImdgPredicate accountTypePredicate = accountPredicateBuilder.and(accountPredicateBuilder.equals("accountType", AccountType.Anlt.getKey()),
+            accountPredicateBuilder.equals("currency", currency));
         ImdgPredicate andPredicate = accountPredicateBuilder.and(companyIdPredicate, accountTypePredicate);
         Collection<Account> accountsAnlt = accountImdg.getCollectionObjectsByPredicate(andPredicate);
         if (accountsAnlt.isEmpty()) {
@@ -173,12 +172,12 @@ public class InformationAccountService extends QueueConsumer implements Initiali
             if (txOk) {
                 imdgTransaction.commitTransaction();
                 log.debug("successfully processed, new information account id {}, new account id {}",
-                        informationAccountId,
-                        accountId);
+                    informationAccountId,
+                    accountId);
             } else {
                 log.debug("failed insert, new information account id {}, new account id {} (if id = -1 then insert is failed)",
-                        informationAccountId,
-                        accountId);
+                    informationAccountId,
+                    accountId);
                 imdgTransaction.rollbackTransaction();
             }
         }
@@ -191,15 +190,13 @@ public class InformationAccountService extends QueueConsumer implements Initiali
         log.debug("InformationAccountNewRequest received (system), request id={}", userRequest.getId());
 
         RequestInfoUpdate requestInfoUpdate;
-//        RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, infoAccountNewRequestValidator);
-//        if (requestInfoUpdate != null) return requestInfoUpdate;
         final Long forCompanyId = userRequest.getRequestPayload().getCompanyId();
 
         ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
-        { // Проверка существования счёта
+        {
             Collection<Account> accountsAnlt = accountImdg.getCollectionObjectsByFieldValues(Map.of(
-                    "companyId", forCompanyId,
-                    "accountType", AccountType.Info.getKey()
+                "companyId", forCompanyId,
+                "accountType", AccountType.Info.getKey()
             ));
             if (!accountsAnlt.isEmpty()) {
                 String trueMessage = messageResolver.resolve(new EnumMessage(AccountError.InfoAccountAlreadyExist, forCompanyId));
@@ -209,16 +206,20 @@ public class InformationAccountService extends QueueConsumer implements Initiali
         }
 
 
+        String currency = userRequest.getRequestPayload().getCurrency();
+        if (currency == null)
+            currency = CurrencyCode.RUB.getKey();
         Long newId = informationAccountImdg.nextIDSequenceFor();
-        Long infoSequenceId = accountNextId(); // требуется последовательность n+1
-        String accountValue = generateInfoAccount(infoSequenceId);
+        Long infoSequenceId = accountNextId(currency, 810L);
+        String accountValue = generateInfoAccount(810L, infoSequenceId);
         log.trace("New info-account id={}, sequenceId={}, account={}", newId, infoSequenceId, accountValue);
 
         Long anltAccountId = null;
         {
             ImdgPredicate andPredicate = pb.and(
-                    pb.equals("companyId", 1L),
-                    pb.equals("accountType", AccountType.Anlt.getKey())
+                pb.equals("companyId", 1L),
+                pb.equals("accountType", AccountType.Anlt.getKey()),
+                pb.equals("currency", currency)
             );
             Collection<Account> accountsAnlt = accountImdg.getCollectionObjectsByPredicate(andPredicate);
             if (accountsAnlt.isEmpty()) {
@@ -267,26 +268,21 @@ public class InformationAccountService extends QueueConsumer implements Initiali
             if (txOk) {
                 imdgTransaction.commitTransaction();
                 log.debug("successfully processed, new information account id {}, new account id {}",
-                        informationAccountId,
-                        accountId);
+                    informationAccountId,
+                    accountId);
             } else {
                 log.debug("failed insert, new information account id {}, new account id {} (if id = -1 then insert is failed)",
-                        informationAccountId,
-                        accountId);
+                    informationAccountId,
+                    accountId);
                 imdgTransaction.rollbackTransaction();
             }
         }
-
-        // send to kafka
         sendNotificationToReport(informationAccount, account);
 
         return null;
     }
 
 
-    /**
-     * Формирование уведолмения о регистрации УК
-     */
     protected void sendNotificationToReport(InformationAccount informationAccount, Account account) {
         NotificationRequest request = new NotificationRequest();
         request.setConsumerId(account.getCompanyId());
@@ -294,29 +290,42 @@ public class InformationAccountService extends QueueConsumer implements Initiali
         kafkaSender.sendRequestToQueue(Consts.CREATE_NOTIFICATION_NCMP, request);
     }
 
-    public String generateInfoAccount(Long id) {
-        return "%d%d%08d%d".formatted(39911, 810, id, 7000);
+    public String generateInfoAccount(Long currencyCodeId, Long id) {
+        return "%d%03d%08d%d".formatted(39911, currencyCodeId, id, 7000);
     }
 
+    public synchronized Long accountNextId(String currency) {
+        return accountNextId(currency, 810L);
+    }
 
-    /**
-     * Сквозной номер инфо-счетов
-     *
-     * @return infoCounter++
-     */
-    public synchronized Long accountNextId() {
+    public synchronized Long accountNextId(String currency, Long currencyCodeId) {
+        String idWithTrailingZero = String.format("%03d", currencyCodeId);
+        if (currency == null)
+            currency = CurrencyCode.RUB.getKey();
+        AtomicLong infoCounter = infoCounterByCurrency.get(currency);
         if (infoCounter == null) synchronized (this) {
             if (infoCounter == null) {
                 log.debug("Init account-information counter.");
-                Collection<Account> allInfoAcc = accountImdg.getCollectionObjectsByFieldValues(Map.of("accountType", AccountType.Info.getKey()));
+                ImdgPredicateBuilder predicateBuilder = accountImdg.predicateBuilder();
+                ImdgPredicate currencyPredicate = predicateBuilder.equals("currency", currency);
+                if (CurrencyCode.RUB.equalsByKey(currency)) {
+                    currencyPredicate = predicateBuilder.or(
+                        currencyPredicate,
+                        predicateBuilder.isNull("currency")
+                    );
+                }
+                Collection<Account> allInfoAcc = accountImdg.getCollectionObjectsByPredicate(predicateBuilder.and(
+                    predicateBuilder.equals("accountType", AccountType.Info.getKey()),
+                    currencyPredicate
+                ));
                 if (allInfoAcc.isEmpty()) {
                     infoCounter = new AtomicLong(1);
                     log.debug("No account information on map. n={}", infoCounter.get());
                 } else {
-                    Pattern accPattern = Pattern.compile("39911810([0-9]{8})7000");
+                    Pattern accPattern = Pattern.compile("39911%s([0-9]{8})7000".formatted(idWithTrailingZero));
                     int maxN = 1;
                     int parsedCount = 0;
-                    String lastAccount = null; // for debug
+                    String lastAccount = null;
                     for (Account acc : allInfoAcc) {
                         try {
                             String number = acc.getAccount();
@@ -337,10 +346,11 @@ public class InformationAccountService extends QueueConsumer implements Initiali
                     }
                     infoCounter = new AtomicLong(maxN);
                     log.debug("Parsed {} information accounts ({} pattern match) in map. n={}",
-                            allInfoAcc.size(), parsedCount, infoCounter.get());
+                        allInfoAcc.size(), parsedCount, infoCounter.get());
                     if (parsedCount == 0 && lastAccount != null)
                         log.debug("Last unparseable account: {}", lastAccount);
                 }
+                infoCounterByCurrency.put(currency, infoCounter);
             }
         }
         return infoCounter.incrementAndGet();

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

@@ -1,42 +1,38 @@
 package ru.spcex.clearing.account.service;
 
+import java.time.Instant;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import org.apache.commons.lang3.tuple.Triple;
 import org.apache.kafka.clients.producer.Producer;
 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.misc.Notification;
 import ru.clearing.classes.statics.data.sdf.SDf52;
 import ru.clearing.classes.statics.data.sdf.SDf53;
 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.balance.ExportToFileRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
-import ru.spcex.clearing.platform.messaging.domain.cud.utilities.NotificationFeedbackRequest;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.platform.enumeration.AccountStatus;
-import ru.spcex.platform.enumeration.NotificationStatus;
-import ru.spcex.platform.enumeration.ObjectType;
 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.ImdgTransaction;
-import ru.spcex.platform.utils.collection.Pair;
-
-import java.time.Instant;
-import java.util.*;
-import java.util.concurrent.CopyOnWriteArrayList;
 
 @Service
 public class SDFProcessService {
-    public static final String SDF_STATUS_OK = "OK"; // (Операция выполнена успешно) - если account обновлена по sDf52;
-    public static final String SDF_STATUS_ERROR_REPEAT = "1"; // (Ошибка. Попытка повторно исполнить операцию)
-    public static final String SDF_STATUS_ERROR_COMPANY_NOT_FOUND = "2"; // (Ошибка. Участник не найден) - если получена ошибка (5013) "Компания %s не найдена" (т.е. account НЕ обновлена по sDf52);
-    public static final String SDF_STATUS_ERROR_LIMIT_SUMM = "3"; // (Ошибка. Сумма списания превышает сумму средств на торговом счете участника в ТС)
-    public static final String SDF_STATUS_ERROR_NO_TRADE = "4"; // (Ошибка. Торги не идут)
-    public static final String SDF_STATUS_ERROR = "9"; // (Другие ошибки, выявленные в КС) - если получены другие ошибки (т.е. account НЕ обновлена по sDf52).
+    public static final String SDF_STATUS_OK = "OK";
+    public static final String SDF_STATUS_ERROR_REPEAT = "1";
+    public static final String SDF_STATUS_ERROR_COMPANY_NOT_FOUND = "2";
+    public static final String SDF_STATUS_ERROR_LIMIT_SUMM = "3";
+    public static final String SDF_STATUS_ERROR_NO_TRADE = "4";
+    public static final String SDF_STATUS_ERROR = "9";
 
     protected static final Long SDF52_STATUS_0Blocked = 0L;
     protected static final Long SDF52_STATUS_1Unblocked = 1L;
@@ -80,7 +76,7 @@ public class SDFProcessService {
         boolean txOk = false;
         imdgTransaction.beginTransaction();
         HashSet<String> fileNames = new HashSet<>();
-        try { // 2. обновление данных, в транзакции
+        try {
             Imdg<SDf53> sdf53Imdg = imdgTransaction.getImdg(IMDGDistributedNames.Map_SDf53, SDf53.class);
 
             Instant now = Instant.now();
@@ -116,12 +112,13 @@ public class SDFProcessService {
         newSdf.setDeal(sdf52.getDeal());
         newSdf.setDate(sdf52.getDate());
         newSdf.setStatus(sdf52.getStatus());
+        newSdf.setAccType(sdf52.getAcc_type());
         newSdf.setResult(result);
         newSdf.setGenerationTime(now);
         newSdf.setGenerationId(sdf52.getGenerationId());
-        if (!Objects.equals(newGenerationId, newSdf.getGenerationId())) { // never
+        if (!Objects.equals(newGenerationId, newSdf.getGenerationId())) {
             log.warn("Different GenerationId={} for sdf53[{}] and GenerationId={} for group of sdf52",
-                    newSdf.getGenerationId(), newSdf.getId(), newGenerationId
+                newSdf.getGenerationId(), newSdf.getId(), newGenerationId
             );
         }
         newSdf.setInSDfId(sdf52.getId());
@@ -129,10 +126,6 @@ public class SDFProcessService {
     }
 
 
-    /**
-     * @param status sdf.getStatus()
-     * @return AccountStatus или null
-     */
     public AccountStatus parseSdf52Status(Long status) {
         if (SDF52_STATUS_1Unblocked.equals(status) || SDF52_STATUS_3Open.equals(status)) {
             return AccountStatus.ACTIVE;
@@ -147,9 +140,9 @@ public class SDFProcessService {
 
 
     void messageStatementToExport53(Long groupId, String fileName) {
-        final String destination = Consts.EXPORT_PROCESS; // dbf-exporter
+        final String destination = Consts.EXPORT_PROCESS;
         ExportToFileRequest request = new ExportToFileRequest();
-        request.setNameOfTable("DF-53"); // SdfTable.SDF_53
+        request.setNameOfTable("DF-53");
         request.setSdfGroupId(groupId);
         request.setFileName(fileName);
         Long msgId = kafkaSender.sendRequestToQueue(destination, request);

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

@@ -0,0 +1,287 @@
+package ru.spcex.clearing.account.service;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+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.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+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.account.ClientCodeNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.clearing.CreateRegistryRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListUpdateRequest;
+import ru.spcex.clearing.platform.messaging.serialization.LogFormatter;
+import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.clearing.util.security.UserRoleVerification;
+import ru.spcex.clearing.util.services.RequestHelper;
+import ru.spcex.clearing.validation.common.ValidationHelper;
+import ru.spcex.platform.enumeration.ServiceStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.log.ExceptionUtils;
+import ru.spcex.platform.utils.validation.IValidator;
+
+@Service
+public class TradingClearingRegistryListService extends QueueConsumer implements InitializingBean {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private final ValidationHelper validationHelper;
+    private final UserRoleVerification userRoleVerification;
+    protected ClientCodeService clientCodeService;
+
+    private final ImdgProvider imdgProvider;
+    private final Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg;
+    private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
+    private final Imdg<DepoAccount> depoAccountImdg;
+    private final Imdg<ClearingAccount> clearingAccountImdg;
+    private final Imdg<InformationAccount> informationAccountImdg;
+    private final Imdg<Account> accountImdg;
+    private final Imdg<Company> companyImdg;
+    private final Imdg<Relation> relationImdg;
+
+    private final Function<TradingClearingRegistryListUpdateRequest, IValidator> tradingClearingRegistryListUpdateRequestValidator;
+    private final RequestHelper requestHelper;
+    private final Function<TradingClearingRegistryListNewRequest, IValidator> tradingClearingRegistryListNewRequestValidator;
+
+    private final IMessageResolver messageResolver;
+    private final Producer<String, Object> kafkaProducer;
+    private final KafkaSender kafkaSender;
+
+    public TradingClearingRegistryListService(Consumer<String, Object> kafkaQueue,
+                                              Producer<String, Object> kafkaProducer,
+                                              KafkaSender kafkaSender,
+                                              ImdgProvider imdgProvider,
+                                              ClientCodeService clientCodeService,
+                                              ValidationHelper validationHelper,
+                                              UserRoleVerification userRoleVerification,
+                                              IMessageResolver messageResolver,
+                                              RequestHelper requestHelper,
+                                              @Qualifier("tradingClearingRegistryListNewRequestValidator")
+                                              Function<TradingClearingRegistryListNewRequest, IValidator> tradingClearingRegistryListNewRequestValidator,
+                                              @Qualifier("tradingClearingRegistryListUpdateRequestValidator")
+                                              Function<TradingClearingRegistryListUpdateRequest, IValidator> tradingClearingRegistryListUpdateRequestValidator
+    ) {
+        super(kafkaQueue, kafkaProducer);
+        this.kafkaProducer = kafkaProducer;
+        this.kafkaSender = kafkaSender;
+        this.validationHelper = validationHelper;
+        this.userRoleVerification = userRoleVerification;
+        this.requestHelper = requestHelper;
+        this.imdgProvider = imdgProvider;
+        this.tradingClearingRegistryListImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+        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.tradingClearingRegistryListNewRequestValidator = tradingClearingRegistryListNewRequestValidator;
+        this.tradingClearingRegistryListUpdateRequestValidator = tradingClearingRegistryListUpdateRequestValidator;
+        this.messageResolver = messageResolver;
+        this.clientCodeService = clientCodeService;
+    }
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        imdgProvider.waitAvailable();
+        callback(TradingClearingRegistryListNewRequest.class)
+            .setFunction(this::tradingClearingRegistryListNew)
+            .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRIES_LIST_NEW, callbacks::put);
+        callback(TradingClearingRegistryListUpdateRequest.class)
+            .setFunction(this::tradingClearingRegistryListUpdate)
+            .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRIES_LIST_UPDATE, callbacks::put);
+        init();
+    }
+
+    public RequestInfoUpdate tradingClearingRegistryListNew(BaseRequest<TradingClearingRegistryListNewRequest> userRequest) {
+        return tradingClearingRegistryListNew1(userRequest, false);
+    }
+
+    @Deprecated
+    protected RequestInfoUpdate tradingClearingRegistryListNew0(BaseRequest<TradingClearingRegistryListNewRequest> userRequest, boolean innerCall) {
+        log.debug("TradingClearingRegistryListNewRequest received");
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) {
+            return requestInfoUpdate;
+        }
+
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryListNewRequestValidator);
+        TradingClearingRegistry tcr = tradingClearingRegistryImdg.getSingleObjectByID(userRequest
+            .getRequestPayload()
+            .getTradingClearingRegistryId());
+
+        if (requestInfoUpdate != null) {
+            return requestInfoUpdate;
+        }
+
+
+        TradingClearingRegistryListNewRequest req = userRequest.getRequestPayload();
+        Instant now = Instant.now();
+
+        List<Long> newIds = new ArrayList<>();
+        for (Long currAccId : req.getCurrencyAccountList()) {
+            Long id = tradingClearingRegistryListImdg.nextIDSequenceFor();
+            TradingClearingRegistryList tradingClearingRegistryList = new TradingClearingRegistryList();
+            tradingClearingRegistryList.setId(id);
+            tradingClearingRegistryList.setCreated(now);
+            tradingClearingRegistryList.setUpdated(now);
+            tradingClearingRegistryList.setTradingClearingRegistryId(req.getTradingClearingRegistryId());
+            tradingClearingRegistryList.setAccountId(currAccId);
+            Account account = accountImdg.getSingleObjectByID(currAccId);
+            tradingClearingRegistryList.setCurrency(account.getCurrency());
+            if (req.getStatus() == null) {
+                tradingClearingRegistryList.setStatus(ServiceStatus.Active.getKey());
+                log.trace("TCRList status in request not set. Use default: {}", tradingClearingRegistryList.getStatus());
+            } else {
+                tradingClearingRegistryList.setStatus(req.getStatus());
+            }
+            tradingClearingRegistryListImdg.insert(tradingClearingRegistryList);
+            newIds.add(id);
+
+        }
+        log.info("New TCRList.id={} has created.", newIds);
+
+        if (!innerCall) {
+            try {
+                ClientCodeNewRequest cCodeReq = new ClientCodeNewRequest();
+                cCodeReq.setTradingClearingRegistryId(req.getTradingClearingRegistryId());
+                cCodeReq.setDepoAccountId(tcr.getDepoAccountId());
+                cCodeReq.setMoneyAccountId(tcr.getMoneyAccountId());
+                cCodeReq.setCompanyId(tcr.getCompanyId());
+                cCodeReq.setCurrencyAccountList(req.getCurrencyAccountList());
+                cCodeReq.setStatus(req.getStatus());
+                BaseRequest<ClientCodeNewRequest> request2 = new BaseRequest<>();
+                request2.setRequestPayload(cCodeReq);
+                requestInfoUpdate = clientCodeService.clientCodeNew0(request2, true);
+                if (requestInfoUpdate != null) return requestInfoUpdate;
+            } catch (Exception e) {
+                log.error("Can not wait creation of tradingClearingRegistryList. request id={}; {}",
+                    userRequest.getId(),
+                    ExceptionUtils.getStackTrace(e));
+                return requestHelper.makeErrorResponse(userRequest, AccountError.GeneralError, "Can not create TCR: " + e.getMessage());
+            }
+
+        }
+
+        sendNotificationToClearingSvc(newIds, tcr);
+
+        log.debug("successfully processed, id {}", newIds);
+        return null;
+    }
+
+
+    protected RequestInfoUpdate tradingClearingRegistryListNew1(BaseRequest<TradingClearingRegistryListNewRequest> userRequest, boolean innerCall) {
+        log.debug("TradingClearingRegistryListNewRequest received");
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) {
+            return requestInfoUpdate;
+        }
+
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryListNewRequestValidator);
+        if (requestInfoUpdate != null) {
+            return requestInfoUpdate;
+        }
+
+        TradingClearingRegistryListNewRequest req = userRequest.getRequestPayload();
+        TradingClearingRegistry tcr = tradingClearingRegistryImdg.getSingleObjectByID(req.getTradingClearingRegistryId());
+        Account account = accountImdg.getSingleObjectByID(req.getAccountId());
+        Instant now = Instant.now();
+
+        Long id = tradingClearingRegistryListImdg.nextIDSequenceFor();
+        TradingClearingRegistryList tradingClearingRegistryList = new TradingClearingRegistryList();
+        tradingClearingRegistryList.setId(id);
+        tradingClearingRegistryList.setCreated(now);
+        tradingClearingRegistryList.setUpdated(now);
+        tradingClearingRegistryList.setTradingClearingRegistryId(req.getTradingClearingRegistryId());
+        tradingClearingRegistryList.setAccountId(req.getAccountId());
+        tradingClearingRegistryList.setCurrency(account.getCurrency());
+        if (req.getStatus() == null) {
+            tradingClearingRegistryList.setStatus(ServiceStatus.Active.getKey());
+            log.trace("TCRList status in request not set. Use default: {}", tradingClearingRegistryList.getStatus());
+        } else {
+            tradingClearingRegistryList.setStatus(req.getStatus());
+        }
+        tradingClearingRegistryListImdg.insert(tradingClearingRegistryList);
+
+        log.info("New TCRList.id={} has created.", id);
+
+        if (!innerCall) {
+
+        }
+
+
+        sendNotificationToClearingSvc(id, tcr);
+
+        log.debug("successfully processed, id {}", id);
+        return null;
+    }
+
+    public RequestInfoUpdate tradingClearingRegistryListUpdate(BaseRequest<TradingClearingRegistryListUpdateRequest> userRequest) {
+        return tradingClearingRegistryListUpdate0(userRequest, false);
+    }
+
+    public RequestInfoUpdate tradingClearingRegistryListUpdate0(BaseRequest<TradingClearingRegistryListUpdateRequest> userRequest, boolean innerCall) {
+        log.debug("TradingClearingRegistryListUpdateRequest received");
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryListUpdateRequestValidator);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        TradingClearingRegistryListUpdateRequest req = userRequest.getRequestPayload();
+        TradingClearingRegistryList tradingClearingRegistryList = tradingClearingRegistryListImdg.getSingleObjectByID(req.getId());
+
+        if (req.getStatus() != null && !Objects.equals(req.getStatus(), tradingClearingRegistryList.getStatus())) {
+            Instant now = Instant.now();
+            tradingClearingRegistryList.setUpdated(now);
+            tradingClearingRegistryList.setStatus(req.getStatus());
+            tradingClearingRegistryListImdg.update(tradingClearingRegistryList);
+            log.debug("Update TCRList.id={}.", tradingClearingRegistryList.getId());
+        } else {
+            log.debug("Nothing to update TCRList.id={}.", tradingClearingRegistryList.getId());
+        }
+
+        log.debug("successfully processed, id {}", tradingClearingRegistryList.getId());
+        return null;
+    }
+
+
+    @Deprecated
+    protected void sendNotificationToClearingSvc(List<Long> tradingClearingRegistries, TradingClearingRegistry tcr) {
+        for (Long tradingClearingRegistryId : tradingClearingRegistries)
+            sendNotificationToClearingSvc(tradingClearingRegistryId, tcr);
+    }
+
+    protected void sendNotificationToClearingSvc(Long tradingClearingRegistryId, TradingClearingRegistry tcr) {
+        CreateRegistryRequest request = new CreateRegistryRequest();
+        request.setTcrListId(tradingClearingRegistryId);
+        request.setCompanyId(tcr.getCompanyId());
+        request.setTradingClearingRegistryId(tcr.getId());
+        log.debug("Send message to kafka \"{}\": {}", Consts.REGISTRY_NEW, LogFormatter.toStringWrapper(request));
+        kafkaSender.sendRequestToQueue(Consts.REGISTRY_NEW, request);
+    }
+
+
+}

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

@@ -1,5 +1,13 @@
 package ru.spcex.clearing.account.service;
 
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -7,23 +15,33 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.ClearingAccount;
+import ru.clearing.classes.statics.data.account.ClientCode;
 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.CompanySymbols;
 import ru.clearing.classes.statics.data.company.relation.Relation;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
 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.account.ClientCodeNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccount;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccountsGatewayRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.clearing.CreateRegistryRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.MoneyAccountMsgResponse;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.SendTkrRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.Tkr;
 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.domain.cud.reports.NotificationRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
 import ru.spcex.clearing.platform.messaging.serialization.LogFormatter;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
@@ -31,7 +49,12 @@ import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 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.CompanySymbol;
+import ru.spcex.platform.enumeration.CurrencyCode;
 import ru.spcex.platform.enumeration.ServiceStatus;
+import ru.spcex.platform.enumeration.Status;
+import static ru.spcex.platform.enumeration.Task.makeFiles_MTCR;
 import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose;
 import ru.spcex.platform.enumeration.TradingClearingRegistryType;
 import ru.spcex.platform.imdg.api.Imdg;
@@ -40,10 +63,6 @@ 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.*;
-import java.util.function.Function;
-
 @Service
 public class TradingClearingRegistryService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -53,12 +72,15 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
 
     private final ImdgProvider imdgProvider;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
+    private final Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg;
     private final Imdg<DepoAccount> depoAccountImdg;
     private final Imdg<ClearingAccount> clearingAccountImdg;
     private final Imdg<InformationAccount> informationAccountImdg;
     private final Imdg<Account> accountImdg;
     private final Imdg<Company> companyImdg;
+    private final Imdg<CompanySymbols> companySymbolsImdg;
     private final Imdg<Relation> relationImdg;
+    private final Imdg<ClientCode> clientCodeImdg;
 
     private final Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator;
     private final RequestHelper requestHelper;
@@ -79,11 +101,11 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
                                           IMessageResolver messageResolver,
                                           RequestHelper requestHelper,
                                           @Qualifier("tradingClearingRegistryNewRequest")
-                                                  Function<TradingClearingRegistryNewRequest, IValidator> tradingClearingRegistryNewRequestValidator,
+                                          Function<TradingClearingRegistryNewRequest, IValidator> tradingClearingRegistryNewRequestValidator,
                                           @Qualifier("tradingClearingRegistryUpdateRequest")
-                                                  Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator,
+                                          Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator,
                                           @Qualifier("tradingClearingRegistryBlockRequest")
-                                                  Function<CommonIdRequest, IValidator> tradingClearingRegistryBlockRequestValidator) {
+                                          Function<CommonIdRequest, IValidator> tradingClearingRegistryBlockRequestValidator) {
         super(kafkaQueue, kafkaProducer);
         this.kafkaProducer = kafkaProducer;
         this.kafkaSender = kafkaSender;
@@ -92,14 +114,17 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
         this.requestHelper = requestHelper;
         this.imdgProvider = imdgProvider;
         this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+        this.tradingClearingRegistryListImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.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.clientCodeImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
+        this.companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
         this.tradingClearingRegistryNewRequestValidator = tradingClearingRegistryNewRequestValidator;
-        this.tradingClearingRegistryAutoNewRequestValidator = tradingClearingRegistryNewRequestValidator; // без relation.
+        this.tradingClearingRegistryAutoNewRequestValidator = tradingClearingRegistryNewRequestValidator;
         this.tradingClearingRegistryUpdateRequestValidator = tradingClearingRegistryUpdateRequestValidator;
         this.tradingClearingRegistryBlockRequestValidator = tradingClearingRegistryBlockRequestValidator;
         this.messageResolver = messageResolver;
@@ -108,18 +133,24 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
     @Override
     public void afterPropertiesSet() throws Exception {
         imdgProvider.waitAvailable();
-        callback(TradingClearingRegistryNewRequest.class) // todo deprecated - unused.
-                .setFunction(this::tradingClearingRegistryAutoNew)
-                .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, callbacks::put);
         callback(TradingClearingRegistryNewRequest.class)
-                .setFunction(this::tradingClearingRegistryNew)
-                .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, callbacks::put);
+            .setFunction(this::tradingClearingRegistryAutoNew)
+            .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, callbacks::put);
+        callback(TradingClearingRegistryNewRequest.class)
+            .setFunction(this::tradingClearingRegistryNew)
+            .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, callbacks::put);
         callback(TradingClearingRegistryUpdateRequest.class)
-                .setFunction(this::tradingClearingRegistryUpdate)
-                .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE, callbacks::put);
+            .setFunction(this::tradingClearingRegistryUpdate)
+            .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE, callbacks::put);
         callback(CommonIdRequest.class)
-                .setFunction(this::tradingClearingRegistryBlock)
-                .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put);
+            .setFunction(this::tradingClearingRegistryBlock)
+            .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put);
+        callback(TkrAccountsGatewayRequest.class)
+            .setFunction(this::tradingClearingRegistryCheck)
+            .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_CHECK, callbacks::put);
+        callback(LauncherCommandRequest.class)
+            .setConsumer(this::sendAllTkrToGateway)
+            .forDestination(makeFiles_MTCR.topic(), callbacks::put);
         init();
     }
 
@@ -143,26 +174,21 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
 
         Account depoAccountMain = req.getDepoAccountId() != null ? accountImdg.getSingleObjectByID(req.getDepoAccountId()) : null;
         DepoAccount depoAccount = depoAccountMain != null ? depoAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", req.getDepoAccountId())) : null;
-
-//        InformationAccount infoAccount = null;
         ClearingAccount clearingAccount = null;
         Account accountMain = null;
         if (req.getMoneyAccountId() != null) {
             clearingAccount = clearingAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", req.getMoneyAccountId()));
-//        if (clearingAccount == null) infoAccount = informationAccountImdg.getSingleObjectByFieldValues(Map.of("accountId", req.getMoneyAccountId()));
-            Long accountId = req.getMoneyAccountId(); //clearingAccount != null ? clearingAccount.getAccountId() : infoAccount.getAccountId();
+            Long accountId = req.getMoneyAccountId();
             accountMain = accountImdg.getSingleObjectByID(accountId);
         }
-
-        // кроссвалидация
         if (req.getMoneyAccountId() == null && (req.getMoneyAccountId() == null || req.getDepoAccountId() == null)) {
             TradingClearingRegistry registryByCompany = tradingClearingRegistryImdg.getFirstObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
             if (registryByCompany == null) {
                 log.trace("Not found registry with companyId={}",
-                        req.getCompanyId());
+                    req.getCompanyId());
                 return requestHelper.makeErrorResponse(userRequest,
-                        AccountError.TradingClearingRegistryNotFound,
-                        req.getCompanyId());
+                    AccountError.TradingClearingRegistryNotFound,
+                    req.getCompanyId());
             }
         }
 
@@ -194,7 +220,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
                 }
                 if (accountId != null) {
                     accountMain = accountImdg.getSingleObjectByID(accountId);
-                    if (accountMain == null) { // never, только с инконсистентными данными
+                    if (accountMain == null) {
                         log.warn("Account {} not exist.", accountId);
                     } else {
                         tradingClearingRegistry.setMoneyAccountId(accountId);
@@ -207,6 +233,12 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
                 targetExistTradingClearingRegistry.setUpdated(Instant.now());
                 tradingClearingRegistryImdg.update(targetExistTradingClearingRegistry);
                 log.debug("successfully processed, id {}. Updated exist TradingClearingRegistry.id={}", id, targetExistTradingClearingRegistry.getId());
+                Optional<Tkr> tkr = createRequestToGateway(tradingClearingRegistry);
+                if (tkr.isPresent()) {
+                    SendTkrRequest sendTkrRequest = new SendTkrRequest();
+                    sendTkrRequest.getTkrs().add(tkr.get());
+                    kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest);
+                }
                 return null;
             }
         }
@@ -245,9 +277,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
         }
         tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType);
 
-        TradingClearingRegistryPurpose registryPurpose;
-        if (req.getDepoAccountId() != null) registryPurpose = TradingClearingRegistryPurpose.C;
-        else registryPurpose = TradingClearingRegistryPurpose.M;
+        TradingClearingRegistryPurpose registryPurpose = TradingClearingRegistryPurpose.C;
         tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey());
 
         Company company = companyImdg.getSingleObjectByID(req.getCompanyId());
@@ -262,9 +292,6 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
 
         tradingClearingRegistryImdg.insert(tradingClearingRegistry);
         log.debug("New TCR.id={} was created", tradingClearingRegistry.getId());
-
-//        sendNotificationToCompanySvc(tradingClearingRegistry); при автосоздании ТКР в company-service не отправлять.
-//        sendNotificationToClearingSvc(tradingClearingRegistry);
         sendNotificationToReportSvc(tradingClearingRegistry);
         sendNotificationToClearingSvc(tradingClearingRegistry);
 
@@ -285,13 +312,12 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
         }
 
         TradingClearingRegistryNewRequest req = userRequest.getRequestPayload();
-        // Дополнительная проверка
         if (req.getMoneyAccountId() == null && (req.getMoneyAccountId() == null || req.getDepoAccountId() == null)) {
             TradingClearingRegistry registryByCompany = tradingClearingRegistryImdg.getFirstObjectByFieldValues(Map.of("companyId", req.getCompanyId()));
             if (registryByCompany == null) {
                 return requestHelper.makeErrorResponse(userRequest,
-                        AccountError.TradingClearingRegistryNotFound,
-                        "companyId=" + req.getCompanyId());
+                    AccountError.TradingClearingRegistryNotFound,
+                    "companyId=" + req.getCompanyId());
             }
         }
 
@@ -323,10 +349,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
             else tradingRegistryType = TradingClearingRegistryType.Owner_A.getKey();
         }
         tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType);
-
-        TradingClearingRegistryPurpose registryPurpose;
-        if (req.getDepoAccountId() != null) registryPurpose = TradingClearingRegistryPurpose.C;
-        else registryPurpose = TradingClearingRegistryPurpose.M;
+        TradingClearingRegistryPurpose registryPurpose = TradingClearingRegistryPurpose.C;
         tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey());
 
         Company company = companyImdg.getSingleObjectByID(req.getCompanyId());
@@ -341,6 +364,12 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
 
         tradingClearingRegistryImdg.insert(tradingClearingRegistry);
         log.info("New TCR.id={} was created.", tradingClearingRegistry.getId());
+        Optional<Tkr> tkr = createRequestToGateway(tradingClearingRegistry);
+        if (tkr.isPresent()) {
+            SendTkrRequest sendTkrRequest = new SendTkrRequest();
+            sendTkrRequest.getTkrs().add(tkr.get());
+            kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest);
+        }
 
         sendNotificationToReportSvc(tradingClearingRegistry);
         sendNotificationToClearingSvc(tradingClearingRegistry);
@@ -352,11 +381,11 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
     protected Long companySequenceNextId(Long companyId, TradingClearingRegistryPurpose registryPurpose, String tradingRegistryType) {
         ImdgPredicateBuilder pb = tradingClearingRegistryImdg.predicateBuilder();
         Collection<TradingClearingRegistry> existTCR = tradingClearingRegistryImdg.getCollectionObjectsByPredicate(
-                pb.and(
-                        pb.equals("companyId", companyId),
-                        pb.equals("tradingClearingRegistryPurpose", registryPurpose.getKey()),
-                        pb.equals("tradingClearingRegistryType", tradingRegistryType)
-                )
+            pb.and(
+                pb.equals("companyId", companyId),
+                pb.equals("tradingClearingRegistryPurpose", registryPurpose.getKey()),
+                pb.equals("tradingClearingRegistryType", tradingRegistryType)
+            )
         );
         if (existTCR.isEmpty()) {
             log.trace("For company id={} not found exist TCR.", companyId);
@@ -394,14 +423,14 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
         if (code.length() > 4)
             code = code.substring(code.length() - 4);
         code = "%4s".formatted(code).replace(' ', '0');
-        code += registryPurpose.getKey(); // C / M / ...
-        String trType = tradingRegistryType + "T"; // 2 символа
+        code += "C";
+        String trType = tradingRegistryType + "T";
         code += trType;
         String sId = "%5s".formatted(id).replace(' ', '0');
         if (sId.length() > 5)
             sId = sId.substring(sId.length() - 5);
         code += sId;
-        return code; // 12 имволов
+        return code;
     }
 
     public RequestInfoUpdate tradingClearingRegistryUpdate(BaseRequest<TradingClearingRegistryUpdateRequest> userRequest) {
@@ -414,23 +443,28 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
 
         TradingClearingRegistryUpdateRequest req = userRequest.getRequestPayload();
         TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId());
-
-        // кроссвалидация - нельзя менять эти поля:
         if (req.getMoneyAccountId() != null && !req.getMoneyAccountId().equals(tradingClearingRegistry.getMoneyAccountId())) {
             return requestHelper.makeErrorResponse(userRequest, AccountError.WrongFieldValue, "MoneyAccountId", req.getMoneyAccountId());
         }
-        if (req.getDepoAccountId() != null && !req.getDepoAccountId().equals(tradingClearingRegistry.getDepoAccountId())) {
+        if (tradingClearingRegistry.getDepoAccountId() != null &&
+            req.getDepoAccountId() != null && !req.getDepoAccountId().equals(tradingClearingRegistry.getDepoAccountId())) {
             return requestHelper.makeErrorResponse(userRequest, AccountError.WrongFieldValue, "DepoAccountId", req.getDepoAccountId());
         }
-//        tradingClearingRegistry.setMoneyAccountId(req.getMoneyAccountId());
-//        tradingClearingRegistry.setDepoAccountId(req.getDepoAccountId());
 
-
-        if (req.getStatus() != null && !Objects.equals(req.getStatus(), tradingClearingRegistry.getStatus())) {
+        if (req.getStatus() != null && !Objects.equals(req.getStatus(), tradingClearingRegistry.getStatus())
+            || req.getDepoAccountId() != null && !req.getDepoAccountId().equals(tradingClearingRegistry.getDepoAccountId())
+        ) {
             Instant now = Instant.now();
             tradingClearingRegistry.setUpdated(now);
             tradingClearingRegistry.setStatus(req.getStatus());
+            tradingClearingRegistry.setDepoAccountId(req.getDepoAccountId());
             tradingClearingRegistryImdg.update(tradingClearingRegistry);
+            Optional<Tkr> tkr = createRequestToGateway(tradingClearingRegistry);
+            if (tkr.isPresent()) {
+                SendTkrRequest sendTkrRequest = new SendTkrRequest();
+                sendTkrRequest.getTkrs().add(tkr.get());
+                kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest);
+            }
             log.debug("Update TCR.id={}.", tradingClearingRegistry.getId());
         } else {
             log.debug("Nothing to update TCR.id={}.", tradingClearingRegistry.getId());
@@ -460,10 +494,126 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
         return null;
     }
 
+    public RequestInfoUpdate tradingClearingRegistryCheck(BaseRequest<TkrAccountsGatewayRequest> gatewayRequest) {
+        TkrAccountsGatewayRequest req = gatewayRequest.getRequestPayload();
+        log.debug("TradingClearingRegistryCheckRequest received with requestId : {}", req.getRequestId());
+        for (TkrAccount accountForCheck : req.getAccounts()) {
+            log.debug("Checking TKR with code: {}", accountForCheck.getTkrCode());
+            TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByFieldValues(
+                Map.of("code", accountForCheck.getTkrCode())
+            );
+            Optional<Tkr> tkr = createRequestToGateway(tradingClearingRegistry);
+            if (tkr.isPresent()) {
+                SendTkrRequest sendTkrRequest = new SendTkrRequest();
+                sendTkrRequest.getTkrs().add(tkr.get());
+                kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest);
+            }
+        }
+        return null;
+    }
+
+    public RequestInfoUpdate sendAllTkrToGateway(BaseRequest<?> gatewayRequest) {
+        Collection<TradingClearingRegistry> tkrs = tradingClearingRegistryImdg.getAllValues();
+        SendTkrRequest sendTkrRequest = new SendTkrRequest();
+        for (TradingClearingRegistry tkr : tkrs) {
+            log.debug("Create TKR request with id: {}", tkr.getId());
+            Optional<Tkr> tkrRequest = createRequestToGateway(tkr);
+            tkrRequest.ifPresent(value -> sendTkrRequest.getTkrs().add(value));
+        }
+        kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest);
+        return null;
+    }
+
+    private Optional<Tkr> createRequestToGateway(TradingClearingRegistry tradingClearingRegistry) {
+        if (tradingClearingRegistry != null) {
+            Tkr tkr = new Tkr();
+            log.debug("Found TKR with id: {} and code: {}", tradingClearingRegistry.getId(), tradingClearingRegistry.getCode());
+            Company company = companyImdg.getSingleObjectByID(tradingClearingRegistry.getCompanyId());
+            CompanySymbols companySymbols = companySymbolsImdg.getSingleObjectByFieldValues(
+                Map.of(
+                    "companySymbol", CompanySymbol.UUID.getKey(),
+                    "companyId", company.getId()
+                )
+            );
+            if (companySymbols == null) {
+                log.warn("CompanySymbols is null, searched by company.id: {}, skip this tkr", company.getId());
+                return Optional.empty();
+            }
+            ClientCode clientCode = clientCodeImdg.getFirstObjectByFieldValues(
+                Map.of("tradingClearingRegistryId", tradingClearingRegistry.getId())
+            );
+            tkr.setCompanyId(companySymbols.getCompanySymbolValue());
+            tkr.setTradingCode(Long.valueOf(company.getTradingCode()));
+            tkr.setTkrCode(tradingClearingRegistry.getCode());
+            tkr.setTkrType(tradingClearingRegistry.getTradingClearingRegistryPurpose());
+            tkr.setActive(Status.Active.equalsByKey(tradingClearingRegistry.getStatus()));
+            String accountType;
+            if (clientCode == null) {
+                if (TradingClearingRegistryType.Client_B.equalsByKey(
+                    tradingClearingRegistry.getTradingClearingRegistryType())) {
+                    accountType = "Клиентский общий";
+                } else {
+                    accountType = "Общий";
+                }
+            } else {
+                tkr.setClientCode(clientCode.getCode());
+                accountType = "Клиентский обособленный";
+            }
+            tkr.setAccountTypeName(accountType);
+            if (tradingClearingRegistry.getDepoAccountId() != null) {
+                Account depoAccount = accountImdg.getSingleObjectByID(tradingClearingRegistry.getDepoAccountId());
+                if (depoAccount != null) {
+                    tkr.setDepoAccount(depoAccount.getAccount());
+                }
+            }
+            {
+                if (tradingClearingRegistry.getMoneyAccountId() != null) {
+                    Account moneyAccount = accountImdg.getSingleObjectByID(tradingClearingRegistry.getMoneyAccountId());
+                    MoneyAccountMsgResponse moneyAccountMsg = new MoneyAccountMsgResponse();
+                    moneyAccountMsg.setAccount(moneyAccount.getAccount());
+                    moneyAccountMsg.setCurrCode(StringUtils.hasText(moneyAccount.getCurrency()) ? moneyAccount.getCurrency() : "RUB");
+                    getEksAccount(moneyAccount).ifPresent(moneyAccountMsg::setEksAccount);
+                    moneyAccountMsg.setActive(Status.Active.equalsByKey(moneyAccount.getStatus()));
+                    tkr.getMoneyAccounts().add(moneyAccountMsg);
+                }
+            }
+            {
+                Collection<TradingClearingRegistryList> tradingClearingRegistries = tradingClearingRegistryListImdg.getCollectionObjectsByFieldValues(
+                    Map.of(
+                        "tradingClearingRegistryId", tradingClearingRegistry.getId()
+                    )
+                );
+                for (TradingClearingRegistryList tkrList : tradingClearingRegistries) {
+                    Account additionalAcc = accountImdg.getSingleObjectByID(tkrList.getAccountId());
+                    MoneyAccountMsgResponse moneyAccountMsg = new MoneyAccountMsgResponse();
+                    moneyAccountMsg.setAccount(additionalAcc.getAccount());
+                    getEksAccount(additionalAcc).ifPresent(moneyAccountMsg::setEksAccount);
+                    moneyAccountMsg.setCurrCode(StringUtils.hasText(additionalAcc.getCurrency()) ? additionalAcc.getCurrency() : "RUB");
+                    moneyAccountMsg.setActive(Status.Active.equalsByKey(additionalAcc.getStatus()));
+                    tkr.getMoneyAccounts().add(moneyAccountMsg);
+                }
+            }
+            return Optional.of(tkr);
+        }
+        return Optional.empty();
+    }
+
+    private Optional<String> getEksAccount(Account account) {
+        if (AccountType.Info.equalsByKey(account.getAccountType())) {
+            String currency = StringUtils.hasText(account.getCurrency()) ? account.getCurrency() : CurrencyCode.RUB.getKey();
+            Account anltAcc = accountImdg.getFirstObjectByFieldValues(
+                Map.of(
+                    "currency", currency,
+                    "accountType", AccountType.Anlt.getKey()
+                )
+            );
+            if (anltAcc != null) {
+                return Optional.of(anltAcc.getAccount());
+            }
+        }
+        return Optional.empty();
+    }
 
-    /**
-     * company-service сообщение об успешном добавлении ТКР клиента с параметром tradingClearingRegistry.code
-     */
     protected void sendNotificationToCompanySvc(TradingClearingRegistry tradingClearingRegistry) {
         ClientCodeNewRequest request = new ClientCodeNewRequest();
         request.setTradingClearingRegistryId(tradingClearingRegistry.getId());
@@ -475,9 +625,6 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
         kafkaSender.sendRequestToQueue(Consts.DESTINATION_CLIENT_CODE_NEW_UM_COMPANY, request);
     }
 
-    /**
-     * clearing-service сообщение на открытие клиринговых регистров;
-     */
     protected void sendNotificationToClearingSvc(TradingClearingRegistry tradingClearingRegistry) {
         CreateRegistryRequest request = new CreateRegistryRequest();
         request.setCompanyId(tradingClearingRegistry.getCompanyId());
@@ -486,9 +633,6 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
         kafkaSender.sendRequestToQueue(Consts.REGISTRY_NEW, request);
     }
 
-    /**
-     * report-service сообщение на формирование уведомления о создании нового ТКР
-     */
     protected void sendNotificationToReportSvc(TradingClearingRegistry tradingClearingRegistry) {
         NotificationRequest request = new NotificationRequest();
         request.setConsumerId(tradingClearingRegistry.getCompanyId());

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

@@ -0,0 +1,130 @@
+package ru.spcex.clearing.account.service.v2;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+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.classes.statics.data.registry.TradingClearingRegistryList;
+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.clearing.platform.messaging.domain.cud.gateway.MoneyAccountMsgResponse;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.Tkr;
+import ru.spcex.platform.enumeration.CompanySymbol;
+import ru.spcex.platform.enumeration.Status;
+import ru.spcex.platform.enumeration.TradingClearingRegistryType;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+@Service
+public class GatewayRequestCreator {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final ImdgProvider imdgProvider;
+
+    public GatewayRequestCreator(ImdgProvider imdgProvider) {
+        this.imdgProvider = imdgProvider;
+    }
+
+    public Tkr crateErrorTkrToGateway(TkrAccount tkrAccount, Optional<String> errorMsg) {
+        Tkr tkr = new Tkr();
+        tkr.setTkrCode(tkrAccount.getTkrCode());
+        tkr.setClientCode(tkrAccount.getClientCode());
+        tkr.setCompanyId(tkrAccount.getCompanyId());
+        tkr.setDepoAccount(tkrAccount.getDepoAccount());
+        tkr.setMoneyAccounts(tkrAccount.getMoneyAccounts()
+            .stream()
+            .map(this::convertAccountToResponse)
+            .collect(Collectors.toList()));
+        errorMsg.ifPresent(tkr::setErrorMessage);
+        return tkr;
+    }
+
+    public Tkr createTkrGatewayReq(TradingClearingRegistry tradingClearingRegistry) {
+        Tkr tkr = new Tkr();
+        log.debug("Found TKR with id: {} and code: {}", tradingClearingRegistry.getId(), tradingClearingRegistry.getCode());
+        Imdg<Company> companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        Imdg<CompanySymbols> companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
+        Imdg<ClientCode> clientCodeImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
+        Imdg<Account> accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg = imdgProvider.
+            getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+
+        Company company = companyImdg.getSingleObjectByID(tradingClearingRegistry.getCompanyId());
+        CompanySymbols companySymbols = companySymbolsImdg.getSingleObjectByFieldValues(
+            Map.of(
+                "companySymbol", CompanySymbol.UUID.getKey(),
+                "companyId", company.getId()
+            )
+        );
+
+        ClientCode clientCode = clientCodeImdg.getFirstObjectByFieldValues(
+            Map.of("tradingClearingRegistryId", tradingClearingRegistry.getId())
+        );
+        tkr.setCompanyId(companySymbols.getCompanySymbolValue());
+        tkr.setTradingCode(Long.valueOf(company.getTradingCode()));
+        tkr.setTkrCode(tradingClearingRegistry.getCode());
+        tkr.setTkrType(tradingClearingRegistry.getTradingClearingRegistryPurpose());
+        tkr.setActive(Status.Active.equalsByKey(tradingClearingRegistry.getStatus()));
+        String accountType;
+        if (clientCode == null) {
+            if (TradingClearingRegistryType.Client_B.equalsByKey(
+                tradingClearingRegistry.getTradingClearingRegistryType())) {
+                accountType = "Клиентский общий";
+            } else {
+                accountType = "Общий";
+            }
+        } else {
+            tkr.setClientCode(clientCode.getCode());
+            accountType = "Клиентский обособленный";
+        }
+        tkr.setAccountTypeName(accountType);
+        if (tradingClearingRegistry.getDepoAccountId() != null) {
+            Account depoAccount = accountImdg.getSingleObjectByID(tradingClearingRegistry.getDepoAccountId());
+            if (depoAccount != null) {
+                tkr.setDepoAccount(depoAccount.getAccount());
+            }
+        }
+        {
+            if (tradingClearingRegistry.getMoneyAccountId() != null) {
+                Account moneyAccount = accountImdg.getSingleObjectByID(tradingClearingRegistry.getMoneyAccountId());
+                MoneyAccountMsgResponse moneyAccountMsg = new MoneyAccountMsgResponse();
+                moneyAccountMsg.setAccount(moneyAccount.getAccount());
+                moneyAccountMsg.setCurrCode(StringUtils.hasText(moneyAccount.getCurrency()) ? moneyAccount.getCurrency() : "RUB");
+                moneyAccountMsg.setActive(Status.Active.equalsByKey(moneyAccount.getStatus()));
+                tkr.getMoneyAccounts().add(moneyAccountMsg);
+            }
+        }
+        {
+            Collection<TradingClearingRegistryList> tradingClearingRegistries = tradingClearingRegistryListImdg.getCollectionObjectsByFieldValues(
+                Map.of(
+                    "tradingClearingRegistryId", tradingClearingRegistry.getId()
+                )
+            );
+            for (TradingClearingRegistryList tkrList : tradingClearingRegistries) {
+                Account additionalAcc = accountImdg.getSingleObjectByID(tkrList.getAccountId());
+                MoneyAccountMsgResponse moneyAccountMsg = new MoneyAccountMsgResponse();
+                moneyAccountMsg.setAccount(additionalAcc.getAccount());
+                moneyAccountMsg.setCurrCode(StringUtils.hasText(additionalAcc.getCurrency()) ? additionalAcc.getCurrency() : "RUB");
+                moneyAccountMsg.setActive(Status.Active.equalsByKey(additionalAcc.getStatus()));
+                tkr.getMoneyAccounts().add(moneyAccountMsg);
+            }
+        }
+        return tkr;
+    }
+
+    private MoneyAccountMsgResponse convertAccountToResponse(MoneyAccountMsgRequest moneyAccountMsgRequest) {
+        MoneyAccountMsgResponse msgResponse = new MoneyAccountMsgResponse();
+        msgResponse.setAccount(moneyAccountMsgRequest.getAccount());
+        msgResponse.setCurrCode(moneyAccountMsgRequest.getCurrCode());
+        return msgResponse;
+    }
+}

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

@@ -0,0 +1,80 @@
+package ru.spcex.clearing.account.service.v2.facade;
+
+import java.time.Instant;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.account.ClientCode;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
+import ru.spcex.platform.classes.base.interfaces.IClearingFacade;
+import ru.spcex.platform.enumeration.TradingClearingRegistryType;
+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.utils.validation.IValidator;
+
+@Service
+public class ClientCodeFacade implements IClearingFacade {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final ImdgId idGenerator;
+    private final ImdgProvider imdgProvider;
+    private final Imdg<ClientCode> clientCodeImdg;
+    private final TradingClearingRegistryFacade tradingClearingRegistryFacade;
+    private final TradingClearingRegistryListFacade tradingClearingRegistryListFacade;
+
+    public ClientCodeFacade(ImdgProvider imdgProvider,
+                            TradingClearingRegistryFacade tradingClearingRegistryFacade, TradingClearingRegistryListFacade tradingClearingRegistryListFacade) {
+        this.idGenerator = imdgProvider.getImdgIdGenerator();
+        this.imdgProvider = imdgProvider;
+        this.clientCodeImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
+        this.tradingClearingRegistryFacade = tradingClearingRegistryFacade;
+        this.tradingClearingRegistryListFacade = tradingClearingRegistryListFacade;
+    }
+
+    public void createClientCode(ClientCodeNewRequest request, IValidator validator) {
+        log.trace("Start process creating new client code");
+        TradingClearingRegistry tradingClearingRegistry;
+        {
+            log.debug("Trading Clearing Registry is not exist, creating...");
+            TradingClearingRegistryNewRequest creationTcrRequest = new TradingClearingRegistryNewRequest();
+            creationTcrRequest.setCompanyId(request.getCompanyId());
+            creationTcrRequest.setMoneyAccountId(request.getMoneyAccountId());
+            creationTcrRequest.setDepoAccountId(request.getDepoAccountId());
+            creationTcrRequest.setTradingClearingRegistryType(TradingClearingRegistryType.Client_B.getKey());
+            tradingClearingRegistry = tradingClearingRegistryFacade.createTradingClearingRegistry(creationTcrRequest, null);
+        }
+        {
+            if (request.getCurrencyAccountList() != null && !request.getCurrencyAccountList().isEmpty()) {
+                TradingClearingRegistryListNewRequest tcrListNew = new TradingClearingRegistryListNewRequest();
+                tcrListNew.setTradingClearingRegistryId(tradingClearingRegistry.getId());
+                tcrListNew.setCurrencyAccountList(request.getCurrencyAccountList());
+                List<Long> tkrListIds = tradingClearingRegistryListFacade.createTradingClearingRegistryList(tcrListNew, null);
+            }
+        }
+
+        {
+            ClientCode clientCode = new ClientCode();
+            clientCode.setCreated(Instant.now());
+            clientCode.setUpdated(clientCode.getCreated());
+
+            clientCode.setCompanyId(request.getCompanyId());
+            clientCode.setCode(request.getCode());
+            clientCode.setMoneyAccountId(request.getMoneyAccountId());
+            clientCode.setDepoAccountId(request.getDepoAccountId());
+            clientCode.setStatus(request.getStatus());
+            clientCodeImdg.insert(clientCode);
+            log.debug("successfully processed, new clientCode id {}", clientCode.getId());
+        }
+    }
+
+    public void lock() {
+    }
+
+    public void unlock() {
+    }
+}

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

@@ -0,0 +1,215 @@
+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.ClearingAccount;
+import ru.clearing.classes.statics.data.account.DepoAccount;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.spcex.clearing.account.model.TradingClearingRegistryBusiness;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.clearing.CreateRegistryRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.reports.NotificationRequest;
+import ru.spcex.clearing.platform.messaging.serialization.LogFormatter;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+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.ImdgPredicateBuilder;
+import ru.spcex.platform.utils.validation.IValidator;
+
+@Service
+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) {
+        Long id = tradingClearingRegistryImdg.nextIDSequenceFor();
+        TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry();
+        tradingClearingRegistry.setId(id);
+        tradingClearingRegistry.setCompanyId(request.getCompanyId());
+        tradingClearingRegistry.setMoneyAccountId(request.getMoneyAccountId());
+        tradingClearingRegistry.setDepoAccountId(request.getDepoAccountId());
+
+        DepoAccount depoAccount = request.getDepoAccountId() != null ?
+            depoAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", request.getDepoAccountId())) : null;
+        ClearingAccount clearingAccount = request.getMoneyAccountId() != null ?
+            clearingAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", request.getMoneyAccountId())) : null;
+
+        if (request.getStatus() == null) {
+            tradingClearingRegistry.setStatus(ServiceStatus.Active.getKey());
+            log.trace("TCR status in request not set. Use default: {}", tradingClearingRegistry.getStatus());
+        } else {
+            tradingClearingRegistry.setStatus(request.getStatus());
+            log.trace("TCR status in request set: {}", tradingClearingRegistry.getStatus());
+        }
+
+        String tradingRegistryType;
+        if (request.getTradingClearingRegistryType() != null) {
+            tradingRegistryType = request.getTradingClearingRegistryType();
+        } else if (depoAccount != null) {
+            tradingRegistryType = depoAccount.getDepoAccountType();
+        } else {
+            if (clearingAccount != null) tradingRegistryType = clearingAccount.getClearingAccountType();
+            else tradingRegistryType = TradingClearingRegistryType.Owner_A.getKey();
+        }
+        tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType);
+        TradingClearingRegistryPurpose registryPurpose = TradingClearingRegistryPurpose.C;
+        tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey());
+
+        Company company = companyImdg.getSingleObjectByID(request.getCompanyId());
+        Long seqId = companySequenceNextId(request.getCompanyId(), registryPurpose, tradingRegistryType);
+        String code = makeCode(company.getClearingCode(), registryPurpose, tradingRegistryType, seqId);
+        log.debug("For new TCR.id={} of companyId={} next sequence={}; code={}", id, request.getCompanyId(), seqId, code);
+        tradingClearingRegistry.setCode(code);
+
+        Instant now = Instant.now();
+        tradingClearingRegistry.setCreated(now);
+        tradingClearingRegistry.setUpdated(now);
+
+        tradingClearingRegistryImdg.insert(tradingClearingRegistry);
+
+        log.info("New TCR.id={} was created.", tradingClearingRegistry.getId());
+        sendNotificationToReportSvc(tradingClearingRegistry);
+        sendNotificationToClearingSvc(tradingClearingRegistry);
+
+        log.debug("successfully processed, id {}", id);
+        return tradingClearingRegistry;
+    }
+
+    public TradingClearingRegistry createTradingClearingRegistry(TradingClearingRegistryBusiness businessRequest) {
+        Long id = tradingClearingRegistryImdg.nextIDSequenceFor();
+        TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry();
+        tradingClearingRegistry.setId(id);
+        tradingClearingRegistry.setCompanyId(businessRequest.getCompany().getId());
+        tradingClearingRegistry.setMoneyAccountId(businessRequest.getMoneyAccount().getId());
+        businessRequest.getDepoAccount().ifPresent(depoAccount ->
+            tradingClearingRegistry.setDepoAccountId(depoAccount.getId()));
+        ;
+        if (businessRequest.getTradingClearingRegistryType().isEmpty()) {
+            if (businessRequest.getDepoAccount().isPresent()) {
+
+            }
+        }
+        TradingClearingRegistryPurpose registryPurpose = TradingClearingRegistryPurpose.C;
+        tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey());
+
+        Company company = businessRequest.getCompany();
+
+        Instant now = Instant.now();
+        tradingClearingRegistry.setCreated(now);
+        tradingClearingRegistry.setUpdated(now);
+
+        tradingClearingRegistryImdg.insert(tradingClearingRegistry);
+
+        log.info("New TCR.id={} was created.", tradingClearingRegistry.getId());
+        sendNotificationToReportSvc(tradingClearingRegistry);
+        sendNotificationToClearingSvc(tradingClearingRegistry);
+
+        log.debug("successfully processed, id {}", id);
+        return tradingClearingRegistry;
+    }
+
+    private Long companySequenceNextId(Long companyId,
+                                       TradingClearingRegistryPurpose registryPurpose,
+                                       String tradingRegistryType) {
+        Imdg<TradingClearingRegistry> tradingClearingRegistryImdg = imdgProvider.getImdg(
+            IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class
+        );
+        ImdgPredicateBuilder pb = tradingClearingRegistryImdg.predicateBuilder();
+        Collection<TradingClearingRegistry> existTCR = tradingClearingRegistryImdg.getCollectionObjectsByPredicate(
+            pb.and(
+                pb.equals("companyId", companyId),
+                pb.equals("tradingClearingRegistryPurpose", registryPurpose.getKey()),
+                pb.equals("tradingClearingRegistryType", tradingRegistryType)
+            )
+        );
+        if (existTCR.isEmpty()) {
+            log.trace("For company id={} not found exist TCR.", companyId);
+            return 1L;
+        }
+        log.trace("For company id={} found {} exist TCR.", companyId, existTCR.size());
+        long maxN = 0;
+        for (TradingClearingRegistry tcr : existTCR) {
+            Long codeN = parseCodeSeqId(tcr.getCode());
+            if (codeN != null) {
+                if (maxN < codeN)
+                    maxN = codeN;
+            }
+        }
+        return maxN + 1;
+    }
+
+    private Long parseCodeSeqId(String code) {
+        if (code == null || code.isBlank())
+            return null;
+        try {
+            String toParse = code.trim();
+            if (toParse.length() > 5)
+                toParse = toParse.substring(toParse.length() - 5);
+            return Long.parseLong(toParse);
+        } catch (NumberFormatException nan) {
+            log.warn("Can not parse number from TCR code \"{}\": {}", code, nan.getMessage());
+        }
+        return null;
+    }
+
+    private String makeCode(String companyClearingCode,
+                            TradingClearingRegistryPurpose registryPurpose,
+                            String tradingRegistryType,
+                            Long id) {
+        String code;
+        code = companyClearingCode;
+        if (code.length() > 4)
+            code = code.substring(code.length() - 4);
+        code = "%4s".formatted(code).replace(' ', '0');
+        code += "C";
+        String trType = tradingRegistryType + "T";
+        code += trType;
+        String sId = "%5s".formatted(id).replace(' ', '0');
+        if (sId.length() > 5)
+            sId = sId.substring(sId.length() - 5);
+        code += sId;
+        return code;
+    }
+
+    private void sendNotificationToClearingSvc(TradingClearingRegistry tradingClearingRegistry) {
+        CreateRegistryRequest request = new CreateRegistryRequest();
+        request.setCompanyId(tradingClearingRegistry.getCompanyId());
+        request.setTradingClearingRegistryId(tradingClearingRegistry.getId());
+        log.debug("Send message to kafka \"{}\": {}", Consts.REGISTRY_NEW, LogFormatter.toStringWrapper(request));
+        kafkaSender.sendRequestToQueue(Consts.REGISTRY_NEW, request);
+    }
+
+    private void sendNotificationToReportSvc(TradingClearingRegistry tradingClearingRegistry) {
+        NotificationRequest request = new NotificationRequest();
+        request.setConsumerId(tradingClearingRegistry.getCompanyId());
+        log.debug("Send message to kafka \"{}\": {}", Consts.CREATE_NOTIFICATION_NTCR, LogFormatter.toStringWrapper(request));
+        kafkaSender.sendRequestToQueue(Consts.CREATE_NOTIFICATION_NTCR, request);
+    }
+}

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

@@ -0,0 +1,87 @@
+package ru.spcex.clearing.account.service.v2.facade;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+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.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.clearing.CreateRegistryRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListNewRequest;
+import ru.spcex.clearing.platform.messaging.serialization.LogFormatter;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.platform.enumeration.ServiceStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+@Service
+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;
+    }
+
+    public static class Stored {
+        TradingClearingRegistry tcr;
+        Account account;
+
+    }
+
+    public List<Long> createTradingClearingRegistryList(TradingClearingRegistryListNewRequest request,
+                                                        Stored stored) {
+        TradingClearingRegistry tcr = tradingClearingRegistryImdg.getSingleObjectByID(request.getTradingClearingRegistryId());
+        Instant now = Instant.now();
+
+        List<Long> newIds = new ArrayList<>();
+        for (Long currAccId : request.getCurrencyAccountList()) {
+            Long id = tradingClearingRegistryListImdg.nextIDSequenceFor();
+            TradingClearingRegistryList tradingClearingRegistryList = new TradingClearingRegistryList();
+            tradingClearingRegistryList.setId(id);
+            tradingClearingRegistryList.setCreated(now);
+            tradingClearingRegistryList.setUpdated(now);
+            tradingClearingRegistryList.setTradingClearingRegistryId(tcr.getId());
+            tradingClearingRegistryList.setAccountId(currAccId);
+            Account account = accountImdg.getSingleObjectByID(currAccId);
+            tradingClearingRegistryList.setCurrency(account.getCurrency());
+            if (request.getStatus() == null) {
+                tradingClearingRegistryList.setStatus(ServiceStatus.Active.getKey());
+                log.trace("TCRList status in request not set. Use default: {}", tradingClearingRegistryList.getStatus());
+            } else {
+                tradingClearingRegistryList.setStatus(request.getStatus());
+            }
+            tradingClearingRegistryListImdg.insert(tradingClearingRegistryList);
+            newIds.add(id);
+
+        }
+        log.info("New TCRList.id={} has created.", newIds);
+        newIds.forEach(listId -> sendNotificationToClearingSvc(listId, tcr));
+        return newIds;
+    }
+
+    private void sendNotificationToClearingSvc(Long tradingClearingRegistryId, TradingClearingRegistry tcr) {
+        CreateRegistryRequest request = new CreateRegistryRequest();
+        request.setTcrListId(tradingClearingRegistryId);
+        request.setCompanyId(tcr.getCompanyId());
+        request.setTradingClearingRegistryId(tcr.getId());
+        log.debug("Send message to kafka \"{}\": {}", Consts.REGISTRY_NEW, LogFormatter.toStringWrapper(request));
+        kafkaSender.sendRequestToQueue(Consts.REGISTRY_NEW, request);
+    }
+}

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

@@ -0,0 +1,185 @@
+package ru.spcex.clearing.account.service.v2.listeners;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+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.stereotype.Service;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.spcex.clearing.account.model.ValidationResult;
+import ru.spcex.clearing.account.service.v2.GatewayRequestCreator;
+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;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccount;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccountsGatewayRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.SendTkrRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.gateway.Tkr;
+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.platform.enumeration.CurrencyCode;
+import ru.spcex.platform.enumeration.TradingClearingRegistryType;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.validation.IValidator;
+
+@Service
+public class ClientCodeMessageListener extends QueueConsumer implements InitializingBean {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final KafkaSender kafkaSender;
+    private final ImdgProvider imdgProvider;
+    private final ClientCodeFacade clientCodeFacade;
+    private final ClientCodeValidator clientCodeValidator;
+    private final GatewayRequestCreator gatewayRequestCreator;
+    private final UserRoleVerification userRoleVerification;
+
+    public ClientCodeMessageListener(Consumer<String, Object> kafkaQueue,
+                                     Producer<String, Object> kafkaProducer,
+                                     KafkaSender kafkaSender,
+                                     ImdgProvider imdgProvider,
+                                     ClientCodeFacade clientCodeFacade,
+                                     ClientCodeValidator clientCodeValidator,
+                                     GatewayRequestCreator gatewayRequestCreator,
+                                     UserRoleVerification userRoleVerification) {
+        super(kafkaQueue, kafkaProducer);
+        this.kafkaSender = kafkaSender;
+        this.imdgProvider = imdgProvider;
+        this.clientCodeFacade = clientCodeFacade;
+        this.clientCodeValidator = clientCodeValidator;
+        this.gatewayRequestCreator = gatewayRequestCreator;
+        this.userRoleVerification = userRoleVerification;
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        imdgProvider.waitAvailable();
+        callback(ClientCodeNewRequest.class)
+            .setFunction(this::clientCodeNewFromBackend)
+            .forDestination(Consts.DESTINATION_CLIENT_CODE_NEW, callbacks::put);
+        callback(TkrAccountsGatewayRequest.class)
+            .setFunction(this::clientCodeNewFromGateway)
+            .forDestination(Consts.DESTINATION_CLIENT_CODE_NEW_FROM_GATEWAY, callbacks::put);
+        callback(TkrAccountsGatewayRequest.class)
+            .setFunction(this::clientCodeNewFromGateway)
+            .forDestination(Consts.DESTINATION_CLIENT_CODE_UPDATE_FROM_GATEWAY, callbacks::put);
+        init();
+    }
+
+    private RequestInfoUpdate clientCodeNewFromGateway(BaseRequest<TkrAccountsGatewayRequest> tkrRequest) {
+        clientCodeFacade.lock();
+        TkrAccountsGatewayRequest gatewayRequest = tkrRequest.getRequestPayload();
+
+        SendTkrRequest sendTkrRequest = new SendTkrRequest();
+        sendTkrRequest.setRequestId(gatewayRequest.getRequestId());
+
+        boolean isAnyoneInvalid = false;
+        Map<TkrAccount, ValidationResult> accountsAfterValidation = new HashMap<>();
+        for (TkrAccount tkrAccount : gatewayRequest.getAccounts()) {
+            ValidationResult validationResult = clientCodeValidator.checkGatewayRequest(tkrAccount);
+            if (!validationResult.isValid()) {
+                log.debug("Validation failed for tkr.client_code {}", tkrAccount.getClientCode());
+                isAnyoneInvalid = true;
+            }
+            accountsAfterValidation.put(tkrAccount, validationResult);
+        }
+        if (isAnyoneInvalid) {
+            log.debug("Create error request to gateway service");
+
+            List<Tkr> tkrs = accountsAfterValidation.entrySet()
+                .stream()
+                .map(tkrAccountValidationResultEntry ->
+                    gatewayRequestCreator.crateErrorTkrToGateway(
+                        tkrAccountValidationResultEntry.getKey(),
+                        tkrAccountValidationResultEntry.getValue().errorMsg()
+                    ))
+                .toList();
+            sendTkrRequest.setTkrs(tkrs);
+            kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest);
+            return null;
+        }
+        for (Map.Entry<TkrAccount, ValidationResult> entry : accountsAfterValidation.entrySet()) {
+            ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest();
+            TkrAccount tkrAccount = entry.getKey();
+            ValidationResult validationResult = entry.getValue();
+            log.debug("Creating new clientCode by tkr account: {}", tkrAccount.getClientCode());
+
+            IValidator validator = validationResult.validator();
+            Company company = validator.getStored(ClientCodeStoreObjects.COMPANY);
+            Optional<Account> depoAccount = validator.getStored(ClientCodeStoreObjects.DEPO_ACCOUNT);
+            Long depoAccountId = depoAccount.map(Account::getId).orElse(null);
+            Map<String, Account> 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);
+            clientCodeNewRequest.setMoneyAccountId(moneyAccount.getId());
+
+            List<Long> 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());
+        }
+        kafkaSender.sendRequestToQueue(Consts.ACCOUNTS_TO_GATEWAY, sendTkrRequest);
+        return null;
+    }
+
+    private RequestInfoUpdate clientCodeNewFromBackend(BaseRequest<ClientCodeNewRequest> clientCodeNewRequest) {
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(clientCodeNewRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+        ClientCodeNewRequest request = clientCodeNewRequest.getRequestPayload();
+        ValidationResult validationResult = clientCodeValidator.checkBackendNewRequest(request);
+        if (!validationResult.isValid()) {
+            return makeErrorResponse(clientCodeNewRequest, validationResult);
+        }
+
+        clientCodeFacade.createClientCode(request, validationResult.validator());
+        return null;
+    }
+
+    private RequestInfoUpdate makeErrorResponse(BaseRequest<ClientCodeNewRequest> clientCodeNewRequest,
+                                                ValidationResult validationResult) {
+        RequestInfoUpdate requestInfoUpdate = new RequestInfoUpdate();
+        requestInfoUpdate.setId(clientCodeNewRequest.getId());
+        requestInfoUpdate.setStatus(Status.Error);
+        validationResult.errorMsg().ifPresent(requestInfoUpdate::setMessage);
+        return requestInfoUpdate;
+    }
+
+    private TradingClearingRegistry selectTradingClearingRegistry(Long companyId, Long moneyAccountId, Long depoAccountId) {
+        Map<String, Comparable<?>> query = new HashMap<>();
+        query.put("companyId", companyId);
+        query.put("moneyAccountId", moneyAccountId);
+        query.put("tradingClearingRegistryType", TradingClearingRegistryType.Client_B.getKey());
+        if (depoAccountId != null) {
+            query.put("depoAccountId", depoAccountId);
+        }
+        Imdg<TradingClearingRegistry> tradingClearingRegistryImdg = imdgProvider
+            .getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+        TradingClearingRegistry result = tradingClearingRegistryImdg.getFirstObjectByFieldValues(query);
+        log.trace("TradingClearingRegistry by: {}; {} found", query, result == null ? "not" : "");
+        return result;
+    }
+}

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/v2/validators/ClientCodeValidator.java

@@ -0,0 +1,58 @@
+package ru.spcex.clearing.account.service.v2.validators;
+
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import ru.spcex.clearing.account.model.ValidationResult;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeUpdateRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.TkrAccount;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.util.security.UserRoleVerification;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.validation.IValidator;
+
+@Service
+public class ClientCodeValidator {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final UserRoleVerification userRoleVerification;
+    private final Function<ClientCodeNewRequest, IValidator> clientCodeNewRequestValidator;
+    private final Function<ClientCodeUpdateRequest, IValidator> clientCodeUpdateRequestValidator;
+    private final Function<CommonDeleteRequest, IValidator> clientCodeDeleteRequestValidator;
+    private final Function<TkrAccount, IValidator> tkrAccountsGatewayValidator;
+    private final IMessageResolver messageResolver;
+
+    public ClientCodeValidator(UserRoleVerification userRoleVerification,
+                               Function<ClientCodeNewRequest, IValidator> clientCodeNewRequestValidator,
+                               Function<ClientCodeUpdateRequest, IValidator> clientCodeUpdateRequestValidator,
+                               Function<CommonDeleteRequest, IValidator> clientCodeDeleteRequestValidator,
+                               Function<TkrAccount, IValidator> tkrAccountsGatewayValidator,
+                               IMessageResolver messageResolver) {
+        this.userRoleVerification = userRoleVerification;
+        this.clientCodeNewRequestValidator = clientCodeNewRequestValidator;
+        this.clientCodeUpdateRequestValidator = clientCodeUpdateRequestValidator;
+        this.clientCodeDeleteRequestValidator = clientCodeDeleteRequestValidator;
+        this.tkrAccountsGatewayValidator = tkrAccountsGatewayValidator;
+        this.messageResolver = messageResolver;
+    }
+
+    public ValidationResult checkGatewayRequest(TkrAccount gatewayAccountRequest) {
+        return standardValidation(tkrAccountsGatewayValidator, gatewayAccountRequest);
+    }
+
+    public ValidationResult checkBackendNewRequest(ClientCodeNewRequest clientCodeNewRequest) {
+        return standardValidation(clientCodeNewRequestValidator, clientCodeNewRequest);
+    }
+
+    private <T> ValidationResult standardValidation(Function<T, IValidator> requestValidator, T request) {
+        IValidator validator = requestValidator.apply(request);
+        Optional<EnumMessage> error = validator.tillFirstError();
+        AtomicReference<Optional<String>> errorMsg = new AtomicReference<>();
+        error.ifPresent(err -> errorMsg.set(Optional.of(messageResolver.resolve(err))));
+        return new ValidationResult(validator, error, errorMsg.get());
+    }
+}

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

@@ -1,5 +1,7 @@
 package ru.spcex.clearing.account.validation;
 
+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.company.Company;
@@ -12,9 +14,6 @@ import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.validation.IValidationRule;
 
-import java.util.Map;
-import java.util.Optional;
-
 public enum AccountValidationRule implements IValidationRule<ImdgValidationContext<BankAccountNewRequest>> {
 
     CompanyPresent() {
@@ -29,7 +28,6 @@ public enum AccountValidationRule implements IValidationRule<ImdgValidationConte
             if (!Status.Active.equalsByKey(company.getWorkflowStatus())) {
                 return of(AccountError.CompanyNotActive);
             }
-//            context.storeObject(ValidationStored.Company, company);
             return empty();
         }
     },

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

@@ -0,0 +1,75 @@
+package ru.spcex.clearing.account.validation;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+import ru.spcex.clearing.account.errors.AccountError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
+import ru.spcex.platform.enumeration.Status;
+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 BackendClientCodeValidationRule implements IValidationRule<ImdgValidationContext<ClientCodeNewRequest>> {
+    AllAccountsPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<ClientCodeNewRequest> context) {
+            ClientCodeNewRequest validatedObject = context.getValidatedObject();
+            List<Long> ids = validatedObject.getCurrencyAccountList();
+            if (ids == null || ids.isEmpty()) {
+                return empty();
+            }
+            Imdg<Account> imdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            for (Long id : ids) {
+                if (id == null) {
+                    return of(AccountError.RequiredFieldEmpty, "accountId");
+                }
+                Account byIdObject = imdg.getSingleObjectByID(id);
+                if (byIdObject == null)
+                    return of(AccountError.AccountNotFound, id, "accountId");
+            }
+
+            return empty();
+        }
+    },
+    TcrIsNotPresentByAccount() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<ClientCodeNewRequest> context) {
+            ClientCodeNewRequest validatedObject = context.getValidatedObject();
+            List<Long> currencyIds = validatedObject.getCurrencyAccountList();
+            Long moneyAccountId = validatedObject.getMoneyAccountId();
+
+            Imdg<TradingClearingRegistry> tradingClearingRegistryImdg =
+                context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+            Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg =
+                context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+
+            TradingClearingRegistry tcrByMoneyAccount = tradingClearingRegistryImdg.getFirstObjectByFieldValues(
+                Map.of(
+                    "moneyAccountId", moneyAccountId,
+                    "status", Status.Active.getKey()
+                ));
+            if (tcrByMoneyAccount != null) {
+                return of(AccountError.TradingClearingRegistryAlreadyExist);
+            }
+
+            for (Long id : currencyIds) {
+                TradingClearingRegistryList tcrList = tradingClearingRegistryListImdg.getFirstObjectByFieldValues(
+                    Map.of(
+                        "accountId", id,
+                        "status", Status.Active.getKey()
+                    ));
+                if (tcrList != null) {
+                    return of(AccountError.AccountForTradingClearingRegistryAlreadyUsed);
+                }
+            }
+
+            return empty();
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+package ru.spcex.clearing.account.validation;
+
+public enum ClientCodeStoreObjects {
+    COMPANY,
+    MONEY_ACCOUNT,
+    DEPO_ACCOUNT,
+    MAPPED_TO_CURRENCY_ACCOUNTS,
+    TRADING_CLEARING_REGISTRY
+}

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

@@ -0,0 +1,160 @@
+package ru.spcex.clearing.account.validation;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+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.company.Company;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+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.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;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidationRule;
+
+public enum GatewayClientCodeValidationRule implements IValidationRule<ImdgValidationContext<TkrAccount>> {
+    CompanyPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<TkrAccount> context) {
+            TkrAccount validatedObject = context.getValidatedObject();
+            Long tradingCode = validatedObject.getTradingCode();
+            if (tradingCode == null) {
+                return of(AccountError.RequiredFieldEmpty, "trading_code");
+            }
+
+            Imdg<Company> 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<EnumMessage> validate(ImdgValidationContext<TkrAccount> context) {
+            TkrAccount validatedObject = context.getValidatedObject();
+            List<MoneyAccountMsgRequest> accountList = validatedObject.getMoneyAccounts();
+            if (accountList == null || accountList.isEmpty()) {
+                return of(AccountError.RequiredFieldEmpty, "money_account");
+            }
+            List<String> currencies = accountList.stream().map(MoneyAccountMsgRequest::getCurrCode).toList();
+            if (!currencies.contains(CurrencyCode.RUB.getKey())) {
+                return of(AccountError.RequiredFieldEmpty, "money_account");
+            }
+            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;
+                if (!StringUtils.hasText(moneyAccountMsg.getAccount())){
+                    return of(AccountError.RequiredFieldEmpty, "account");
+                }
+                ImdgPredicate accountPredicate = predicateBuilder.equals("account", moneyAccountMsg.getAccount());
+                if (moneyAccountMsg.getCurrCode().equals(CurrencyCode.RUB.getKey())) {
+                    currencyPredicate = predicateBuilder.or(
+                        predicateBuilder.equals("currency", CurrencyCode.RUB.getKey()),
+                        predicateBuilder.isNull("currency")
+                    );
+                } else {
+                    currencyPredicate = predicateBuilder.equals("currency", moneyAccountMsg.getCurrCode());
+                }
+                Account account = imdg.getFirstObjectByPredicate(
+                    predicateBuilder.and(accountPredicate, currencyPredicate)
+                );
+                if (account == null) {
+                    return of(AccountError.ACCOUNT_NOT_FOUND_GTW, moneyAccountMsg.getAccount(), "money_account");
+                }
+                accountByCurrency.put(account.getCurrency(), account);
+            }
+            context.storeObject(ClientCodeStoreObjects.MAPPED_TO_CURRENCY_ACCOUNTS, accountByCurrency);
+            return Optional.empty();
+        }
+    },
+    DepoAccountsPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<TkrAccount> context) {
+            TkrAccount validatedObject = context.getValidatedObject();
+            String depoAccountVal = validatedObject.getDepoAccount();
+            if (!StringUtils.hasText(depoAccountVal)) {
+                context.storeObject(ClientCodeStoreObjects.DEPO_ACCOUNT, Optional.empty());
+                return empty();
+            }
+
+            Imdg<Account> 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();
+        }
+    },
+    TcrIsNotPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<TkrAccount> context) {
+            Map<String, Account> accountByCurrency = context.getStoredObject(ClientCodeStoreObjects.MAPPED_TO_CURRENCY_ACCOUNTS);
+            Account moneyAccount = accountByCurrency.get(CurrencyCode.RUB.getKey());
+            if (moneyAccount == null) {
+                return of(AccountError.AccountNotFound);
+            }
+            Imdg<TradingClearingRegistry> imdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry,
+                TradingClearingRegistry.class);
+
+            TradingClearingRegistry tcr = imdg.getFirstObjectByFieldValues(
+                Map.of(
+                    "moneyAccountId", moneyAccount.getId(),
+                    "status", Status.Active.getKey()
+                )
+            );
+            if (tcr != null) {
+                return of(AccountError.TradingClearingRegistryAlreadyExist, tcr.getCode(), "code");
+            }
+            return Optional.empty();
+        }
+    },
+    TcrListIsNotPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<TkrAccount> context) {
+            Map<String, Account> accountByCurrency = context.getStoredObject(ClientCodeStoreObjects.MAPPED_TO_CURRENCY_ACCOUNTS);
+            List<Account> currencyAccounts = accountByCurrency.entrySet().stream()
+                .filter(stringAccountEntry -> !stringAccountEntry.getKey().equals(CurrencyCode.RUB.getKey()))
+                .map(Map.Entry::getValue).toList();
+            if (currencyAccounts.isEmpty()) {
+                return empty();
+            }
+            List<String> currencies = currencyAccounts.stream().map(Account::getCurrency).toList();
+            Imdg<TradingClearingRegistryList> imdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList,
+                TradingClearingRegistryList.class);
+            ImdgPredicateBuilder predicateBuilder = imdg.predicateBuilder();
+            Collection<TradingClearingRegistryList> tcrList = imdg.getCollectionObjectsByPredicate(
+                predicateBuilder.and(
+                    predicateBuilder.in("currency", currencies.toArray(new String[0])),
+                    predicateBuilder.equals("status", Status.Active.getKey())
+                ));
+            if (!tcrList.isEmpty()) {
+                return of(AccountError.TradingClearingRegistryAlreadyExist, tcrList.iterator().next().getCurrency(), "currency");
+            }
+            return Optional.empty();
+        }
+    }
+}

clearing-parent/account-service/src/main/resources/logback.xml

@@ -1,38 +1,56 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <configuration>
+    <property name="LOG_PATH" value="./log" />
+    <property name="FILE_NAME" value="account-service" />
+    <property name="CONSOLE_LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %class{0}:%line - %message%n" />
+    <property name="FILE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %class{0}:%msg%n" />
     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
         <encoder>
             <!--            |%X{ru.nbch.scoring.web.logging.mdc_key}-->
-            <Pattern>%date{HH:mm:ss.SSS} [%thread] %-5level %class{0}:%line - %message%n</Pattern>
+            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
             <charset>utf-8</charset>
         </encoder>
     </appender>
-    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <file>./logs/account-service.log</file>
+    <!-- first FILE TEXT appender -->
+    <appender name="TEXT_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${LOG_PATH}/${FILE_NAME}-text.log</file>
         <encoder>
             <!--            |%X{ru.nbch.scoring.web.logging.mdc_key}-->
-            <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %class{0}:%msg%n</Pattern>
+            <Pattern>${FILE_LOG_PATTERN}</Pattern>
             <charset>utf8</charset>
         </encoder>
-        <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
-            <fileNamePattern>
-                ./logs/account-service.%i.log
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${LOG_PATH}/${FILE_NAME}-text.%d{yyyy-MM-dd}.%i.gz
             </fileNamePattern>
-            <minIndex>1</minIndex>
-            <maxIndex>10</maxIndex>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <maxHistory>10</maxHistory>
+        </rollingPolicy>
+    </appender>
+    <!-- second FILE JSON appender -->
+    <appender name="JSON_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${LOG_PATH}/${FILE_NAME}-json.log</file>
+        <encoder class="net.logstash.logback.encoder.LogstashEncoder" />
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${LOG_PATH}/${FILE_NAME}-json.%d{yyyy-MM-dd}.%i.gz
+            </fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <maxHistory>10</maxHistory>
         </rollingPolicy>
-        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
-            <maxFileSize>500MB</maxFileSize>
-        </triggeringPolicy>
     </appender>
 
-    <root level="warn">
-        <appender-ref ref="CONSOLE"/>
-        <appender-ref ref="FILE"/>
+    <root level="info">
+        <!-- <appender-ref ref="CONSOLE"/> -->
+        <appender-ref ref="TEXT_FILE"/>
+        <appender-ref ref="JSON_FILE" />
     </root>
 
     <logger name="ru.spcex" level="debug" additivity="false">
-        <appender-ref ref="FILE"/>
-        <appender-ref ref="CONSOLE"/>
+        <appender-ref ref="TEXT_FILE"/>
+        <appender-ref ref="JSON_FILE" />
+        <!-- <appender-ref ref="CONSOLE"/> -->
     </logger>
 </configuration>

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/AccountServiceTest.java

@@ -186,15 +186,11 @@ class AccountServiceTest {
 
 
         String jsonString = getJsonStringForUpdate(correspondentAccountUpdateRequest, 0);
-
-        //ACT
         addRecordToKafka((MockConsumer) accountService.getConsumer(),
-                Consts.DESTINATION_CORRESPONDENT_ACCOUNT_UPDATE,
-                PARTITION,
-                0,
-                jsonString);
-
-        //ASSERT
+            Consts.DESTINATION_CORRESPONDENT_ACCOUNT_UPDATE,
+            PARTITION,
+            0,
+            jsonString);
         waitingSendAndCheckRecord(0L, mockProducer);
 
         Account resultUpdating = accountImdg.getSingleObjectByID(accountId);
@@ -224,15 +220,11 @@ class AccountServiceTest {
         commonDeleteRequest.setId(accountId);
 
         String jsonString = getJsonStringForDelete(commonDeleteRequest, 0);
-
-        //ACT
         addRecordToKafka((MockConsumer) accountService.getConsumer(),
-                Consts.DESTINATION_CORRESPONDENT_ACCOUNT_BLOCK,
-                PARTITION,
-                0,
-                jsonString);
-
-        //ASSERT
+            Consts.DESTINATION_CORRESPONDENT_ACCOUNT_BLOCK,
+            PARTITION,
+            0,
+            jsonString);
         waitingSendAndCheckRecord(0L, mockProducer);
 
         Account resultBlock = accountImdg.getSingleObjectByID(accountId);

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/AccountSymbolsServiceTest.java

@@ -96,7 +96,6 @@ class AccountSymbolsServiceTest {
 
     @PreDestroy
     private void destroyTest() {
-        //clean test data
         Account account = accountImdg.getSingleObjectByID(accountId);
         if (account != null)
             accountImdg.delete(account);
@@ -130,7 +129,7 @@ class AccountSymbolsServiceTest {
         predictableAccountSymbols.setId(resultNew.getId());
 
         ACCOUNT_SYMBOL_MATCHER.assertMatch(resultNew, predictableAccountSymbols);
-        accountSymbolsImdg.delete(resultNew); // cleanup test
+        accountSymbolsImdg.delete(resultNew);
 
         newRequestCnt++;
     }
@@ -146,15 +145,11 @@ class AccountSymbolsServiceTest {
         accountSymbolsDeleteRequest.setId(accountSymbolId);
 
         String jsonString = getJsonStringForDelete(accountSymbolsDeleteRequest, 0);
-
-        //ACT
         addRecordToKafka((MockConsumer) accountSymbolsService.getConsumer(),
-                Consts.DESTINATION_DEPO_ACCOUNT_SYMBOLS_DELETE,
-                PARTITION,
-                0,
-                jsonString);
-
-        //ASSERT
+            Consts.DESTINATION_DEPO_ACCOUNT_SYMBOLS_DELETE,
+            PARTITION,
+            0,
+            jsonString);
         waitingSendAndCheckRecord(0L, mockProducer);
 
         AccountSymbols resultUpdating = accountSymbolsImdg.getSingleObjectByID(accountSymbolId);

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/BankAccountServiceTest.java

@@ -79,6 +79,7 @@ public class BankAccountServiceTest {
     private static final String correspondentAccountName = "BIK OF TINKOFF";
     private static final String taxpayerIdentificationNumber = "848484848484";
     private static final String taxRegistrationReasonCode = "886886";
+    private static final String swiftCode = "SWIFT_code";
     protected final Long addresseeIdNew = 2L;
     protected final String deal = "111111111";
     private final String acc = "0123456789";
@@ -126,23 +127,8 @@ public class BankAccountServiceTest {
         new TestObjectCreator(hazelcastServiceTest).createUserAdmin(1000L);
     }
 
-    /**
-     * {@link BankAccountService#bankAccountNew(BaseRequest request)}<br>
-     * Тест проверяет генерацию сущности {@link BankAccount} в Hazelcast при передаче из Apache Kafka.<br>
-     * Входной запрос {@link BankAccountNewRequest}:<br>
-     * {@link BankAccountNewRequest#bankIdentificationCode} - 99999<br>
-     * {@link BankAccountNewRequest#bankName} - ооо тинькофф<br>
-     * {@link BankAccountNewRequest#correspondentAccount} - 9294189285498598598<br>
-     * {@link BankAccountNewRequest#correspondentAccountName} - BIK OF<br>
-     * {@link BankAccountNewRequest#currency} - RUB<br>
-     * {@link BankAccountNewRequest#destination} - OOO ROGA I KOPITA<br>
-     * {@link BankAccountNewRequest#taxpayerIdentificationNumber} - 848484848484<br>
-     * {@link BankAccountNewRequest#taxRegistrationReasonCode} - 886886<br>
-     * {@link BankAccountNewRequest#account} - 123456789123<br>
-     */
     @Test
     public void bankAccountNew() {
-        //ARRANGE
         BankAccount predictableBankAccount = getBankAccount();
 
         Company company = getTestCompany();
@@ -167,8 +153,6 @@ public class BankAccountServiceTest {
 
         BankAccountNewRequest bankAccountNewRequest = getBankAccountNewRequest(predictableBankAccount);
         String jsonString = getJsonStringForNew(bankAccountNewRequest, ID);
-
-        //ACT
         addRecordToKafka((MockConsumer) bankAccountService.getConsumer(), TOPIC_ACCOUNT_NEW, PARTITION, 0, jsonString);
         waitingSendAndCheckRecord(ID, mockProducer);
 
@@ -177,26 +161,10 @@ public class BankAccountServiceTest {
         predictableBankAccount.setAccountId(accountResult.getId());
         predictableBankAccount.setId(bankAccountResult.getId());
         setSameValueToField(accountResult, predictableAccount);
-
-        //ASSERT
         BANK_ACCOUNT_MATCHER.assertMatch(bankAccountResult, predictableBankAccount);
         ACCOUNT_MATCHER.assertMatch(accountResult, predictableAccount);
     }
 
-    /**
-     * {@link BankAccountService#bankAccountNew(BaseRequest request)}<br>
-     * Тест проверяет валидацию.<br>
-     * Входной запрос {@link BankAccountNewRequest}:<br>
-     * {@link BankAccountNewRequest#bankIdentificationCode} - 99999<br>
-     * {@link BankAccountNewRequest#bankName} - ооо тинькофф<br>
-     * {@link BankAccountNewRequest#correspondentAccount} - 9294189285498598598<br>
-     * {@link BankAccountNewRequest#correspondentAccountName} - BIK OF<br>
-     * {@link BankAccountNewRequest#currency} - RUB<br>
-     * {@link BankAccountNewRequest#destination} - OOO ROGA I KOPITA<br>
-     * {@link BankAccountNewRequest#taxpayerIdentificationNumber} - 848484848484<br>
-     * {@link BankAccountNewRequest#taxRegistrationReasonCode} - 886886<br>
-     * {@link BankAccountNewRequest#account} - 123456789123<br>
-     */
     @Test
     public void validatedBankAccountNew() {
         clearImdg(accountImdg);
@@ -206,8 +174,6 @@ public class BankAccountServiceTest {
         BankAccountNewRequest bankAccountNewRequest = getBankAccountNewRequest(predictableBankAccount);
 
         String errMsg;
-        //AccountValidationRule.RequiredFields
-        //WrongFieldValue
         bankAccountNewRequest.setCurrency(null);
         errMsg = messageResolver.resolve(new EnumMessage(AccountError.RequiredFieldEmpty, "null, currency"));
         checkError(errMsg, bankAccountNewRequest);
@@ -232,17 +198,11 @@ public class BankAccountServiceTest {
         checkError(errMsg, bankAccountNewRequest);
 
         bankAccountNewRequest.setAccount(acc);
-
-        //AccountValidationRule.CompanyPresent
-        //CompanyNotFound
         bankAccountNewRequest.setCompanyId(999924535239L);
-        errMsg = messageResolver.resolve(new EnumMessage(AccountError.CompanyNotFound, bankAccountNewRequest.getCompanyId()+", companyId"));
+        errMsg = messageResolver.resolve(new EnumMessage(AccountError.CompanyNotFound, bankAccountNewRequest.getCompanyId() + ", companyId"));
         checkError(errMsg, bankAccountNewRequest);
 
         bankAccountNewRequest.setCompanyId(company.getId());
-
-        //AccountValidationRule.AccountIsNew
-        //AccountAlreadyExist
         Account existAccount = getTestAccount(accountId, acc);
         accountImdg.insert(existAccount);
         errMsg = messageResolver.resolve(new EnumMessage(AccountError.AccountAlreadyExist, existAccount.getAccount()));
@@ -251,7 +211,6 @@ public class BankAccountServiceTest {
     }
 
     private void checkError(String errorMsg, BankAccountNewRequest bankAccountNewRequest) {
-        //ARRANGE
         int currentTime = countRun.getAndIncrement();
         long currentOffset = currentTime;
         BaseRequest<Object> predictableBaseRequest = new BaseRequest<>();
@@ -264,41 +223,19 @@ public class BankAccountServiceTest {
         predictableBaseRequest.setRequestPayload(requestInfoUpdate);
 
         String jsonString = getJsonStringForNew(bankAccountNewRequest, ID);
-
-        //ACT
         addRecordToKafka((MockConsumer) bankAccountService.getConsumer(), TOPIC_ACCOUNT_NEW, PARTITION, currentOffset, jsonString);
 
         ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(mockProducer);
-        //waiting for kafka producer send message (finale event)
         verify(mockProducer, timeout(30_000L).times(currentTime))
-                .send(producerRecord.capture());
+            .send(producerRecord.capture());
         BaseRequest<Object> baseRequestResult = (BaseRequest<Object>) producerRecord.getValue().value();
-
-        //ASSERT
         assertEquals(Consts.REQUEST_INFO_UPDATE, producerRecord.getValue().topic());
         BASE_REQUEST_MATCHER.assertMatch(baseRequestResult, predictableBaseRequest);
     }
 
-    /**
-     * {@link BankAccountService#bankAccountUpdate(BaseRequest)}<br>
-     * Тест проверяет обновление сущности {@link BankAccount} в Hazelcast при передаче из Apache Kafka.<br>
-     * Входной запрос {@link BankAccountUpdateRequest}:<br>
-     * {@link BankAccountUpdateRequest#bankIdentificationCode} - NEW BUNK NAME<br>
-     * {@link BankAccountUpdateRequest#bankName} - 88888<br>
-     * {@link BankAccountUpdateRequest#correspondentAccount} - 894984646541316<br>
-     * {@link BankAccountUpdateRequest#correspondentAccountName} - BIK OF NEW BUNK<br>
-     * {@link BankAccountUpdateRequest#currency} - EU<br>
-     * {@link BankAccountUpdateRequest#destination} - OOO NEW BUNK<br>
-     * {@link BankAccountUpdateRequest#taxpayerIdentificationNumber} - 65468461321<br>
-     * {@link BankAccountUpdateRequest#taxRegistrationReasonCode} - 532137<br>
-     * {@link BankAccountUpdateRequest#account} - 326984656514<br>
-     */
     @Test
     void bankAccountUpdate() {
         clearImdg(accountImdg);
-        //ARRANGE
-//        Company company = getTestCompany();
-//        companyImdg.insert(company);
         Account predictableAccount = getTestAccount(accountId, acc);
         accountImdg.insert(predictableAccount);
 
@@ -314,6 +251,7 @@ public class BankAccountServiceTest {
         predictableUpdateBankAccount.setTaxpayerIdentificationNumber("65468461321");
         predictableUpdateBankAccount.setTaxRegistrationReasonCode("532137");
         predictableUpdateBankAccount.setAccount(acc);
+        predictableUpdateBankAccount.setSwiftCode("SWIFT_2");
         predictableUpdateBankAccount.setId(ID);
 
         BankAccountUpdateRequest bankAccountUpdateRequest = new BankAccountUpdateRequest();
@@ -327,13 +265,10 @@ public class BankAccountServiceTest {
         bankAccountUpdateRequest.setTaxpayerIdentificationNumber(predictableUpdateBankAccount.getTaxpayerIdentificationNumber());
         bankAccountUpdateRequest.setTaxRegistrationReasonCode(predictableUpdateBankAccount.getTaxRegistrationReasonCode());
         bankAccountUpdateRequest.setAccount(predictableUpdateBankAccount.getAccount());
+        bankAccountUpdateRequest.setSwiftCode(predictableUpdateBankAccount.getSwiftCode());
 
         String jsonString = getJsonStringForUpdate(bankAccountUpdateRequest, ID);
-
-        //ACT
         addRecordToKafka((MockConsumer) bankAccountService.getConsumer(), TOPIC_ACCOUNT_UPDATE, PARTITION, 0, jsonString);
-
-        //ASSERT
         waitingSendAndCheckRecord(ID, mockProducer);
 
         Account accountResult = accountImdg.getSingleObjectByID(predictableAccount.getId());
@@ -345,15 +280,8 @@ public class BankAccountServiceTest {
         ACCOUNT_MATCHER.assertMatch(accountResult, predictableAccount);
     }
 
-    /**
-     * {@link BankAccountService#bankAccountBlock(BaseRequest)}
-     * Тест проверяет удаление сущности {@link BankAccount} в Hazelcast при передаче из Apache Kafka.
-     * Входной запрос {@link CommonDeleteRequest}:
-     * {@link CommonDeleteRequest#id} - Идентификатор записи
-     */
     @Test
     void bankAccountBlock() {
-        //ARRANGE
         BankAccount bankAccountExists = getBankAccount();
         bankAccountImdg.insert(bankAccountExists);
         Account account = new Account();
@@ -364,11 +292,7 @@ public class BankAccountServiceTest {
         CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
         commonDeleteRequest.setId(ID);
         String jsonString = getJsonStringForDelete(commonDeleteRequest, ID);
-
-        //ACT
         addRecordToKafka((MockConsumer) bankAccountService.getConsumer(), TOPIC_ACCOUNT_DELETE, PARTITION, 0, jsonString);
-
-        //ASSERT
         waitingSendAndCheckRecord(ID, mockProducer);
 
         Account bankAccount = accountImdg.getSingleObjectByID(accountId);
@@ -392,6 +316,7 @@ public class BankAccountServiceTest {
         account.setAccountType(AccountType.Bank.getKey());
         account.setStatus(Status.Active.getKey());
         account.setProcessingSign(Allowed.ALLOWED.getKey());
+        account.setCurrency(currency);
         return account;
     }
 
@@ -415,6 +340,8 @@ public class BankAccountServiceTest {
         bankAccount.setDestination(destination);
         bankAccount.setTaxpayerIdentificationNumber(taxpayerIdentificationNumber);
         bankAccount.setTaxRegistrationReasonCode(taxRegistrationReasonCode);
+        bankAccount.setCurrency(currency);
+        bankAccount.setSwiftCode(swiftCode);
         return bankAccount;
     }
 
@@ -430,6 +357,8 @@ public class BankAccountServiceTest {
         bankAccountNewRequest.setTaxRegistrationReasonCode(bankAccount.getTaxRegistrationReasonCode());
         bankAccountNewRequest.setAccount(bankAccount.getAccount());
         bankAccountNewRequest.setCompanyId(bankAccount.getCompanyId());
+        bankAccountNewRequest.setCurrency(bankAccount.getCurrency());
+        bankAccountNewRequest.setSwiftCode(bankAccount.getSwiftCode());
         return bankAccountNewRequest;
     }
 

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java

@@ -233,19 +233,8 @@ class ClearingAccountServiceTest {
         Assertions.assertEquals("2", clearingAccountService.makeSdfErrorText(null, SDFProcessService.SDF_STATUS_ERROR_COMPANY_NOT_FOUND));
     }
 
-    /**
-     * {@link ClearingAccountService#accountNewSdf01(BaseRequest)}<br>
-     * Тест проверяет создание сущности {@link BaseRequest} в Hazelcast при передаче из Apache Kafka.<br>
-     * Входной запрос {@link AccountSdf01Request}:<br>
-     * {@link AccountSdfRequestPart#setSdfId} - текущий Id<br>
-     * {@link AccountSdfRequestPart#setAccount} - 123456789123<br>
-     * {@link AccountSdfRequestPart#setCompanyId} - текущий Id<br>
-     * {@link AccountSdf01Request#setGroupingSdf01Id} - текущий Id<br>
-     * {@link AccountSdf01Request#setAccounts} - Collections.singletonList(AccountSdfRequestPart)<br>
-     */
     @Test
     void accountSdf01New() throws InterruptedException {
-        //ARRANGE
         clearImdg(accountImdg);
         setMockFuture(kafkaTemplate);
         Long firstID = currentID.getAndIncrement();
@@ -268,15 +257,10 @@ class ClearingAccountServiceTest {
         predictableAccount.setRelationId(relationId);
         ClearingAccount predictableClearingAccount = new ClearingAccount();
         predictableClearingAccount.setCompanyId(companyId);
-//        predictableClearingAccount.setClearingAccountType(CLEARING_ACCOUNT_TYPE_DICT);
-
-        //KAFKA
         addRecordToKafka((MockConsumer) clearingAccountService.getConsumer(), Consts.ACCOUNT_NEW_SDF01, PARTITION, 0, jsonString);
         waitingSendAndCheckRecord(0L, mockProducer);
 
         ImdgHazelcast<Account> accountImdg = (ImdgHazelcast<Account>) hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Account, Account.class);
-
-        //ASSERT
         Account accountResult = accountImdg.getSingleObjectBySQL(String.format("account = %s", ACCOUNT_VALUE));
         ClearingAccount resultClearingAccountNew = clearingAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", accountResult.getId()));
         predictableAccount.setId(accountResult.getId());

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClientCodeServiceTest.java

@@ -19,9 +19,11 @@ import ru.clearing.classes.statics.data.account.DepoAccount;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.profile.CompanyInfo;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
 import ru.clearing.platform.dictionary.*;
 import ru.spcex.clearing.account.config.BeanConfiguration;
 import ru.spcex.clearing.account.config.validation.ClientCodeValidationConfig;
+import ru.spcex.clearing.account.config.validation.TradingClearingRegistryListValidationConfig;
 import ru.spcex.clearing.account.config.validation.TradingClearingRegistryValidationConfig;
 import ru.spcex.clearing.account.config.validation.ValidationConfig;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
@@ -35,6 +37,8 @@ import ru.spcex.clearing.test.TestObjectCreator;
 import ru.spcex.clearing.test.TestUtils;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.ServiceStatus;
 import ru.spcex.platform.enumeration.TradingClearingRegistryType;
 import ru.spcex.platform.enumeration.WorkflowStatus;
 import ru.spcex.platform.imdg.api.Imdg;
@@ -42,22 +46,27 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
 
 import javax.annotation.PostConstruct;
 
+import java.util.Arrays;
+
 import static org.junit.jupiter.api.Assertions.*;
 import static ru.spcex.clearing.test.TestUtils.waitingSendAndCheckRecord;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
-        ClientCodeService.class,
-        ClientCodeValidationConfig.class,
+    ClientCodeService.class,
+    ClientCodeValidationConfig.class,
 
-        TradingClearingRegistryService.class,
-        TradingClearingRegistryValidationConfig.class,
+    TradingClearingRegistryService.class,
+    TradingClearingRegistryValidationConfig.class,
 
-        ValidationConfig.class,
-        BeanConfiguration.class,
+    TradingClearingRegistryListService.class,
+    TradingClearingRegistryListValidationConfig.class,
 
-        KafkaTestConfig.class,
-        ImdgTestConfig.class})
+    ValidationConfig.class,
+    BeanConfiguration.class,
+
+    KafkaTestConfig.class,
+    ImdgTestConfig.class})
 class ClientCodeServiceTest {
 
     private static final int PARTITION = 0;
@@ -79,17 +88,15 @@ class ClientCodeServiceTest {
     protected Producer<String, Object> mockProducer;
 
     private Imdg<ClientCode> clientCodeImdg;
-
-
-    // ****************************-*******************
+    private Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg;
 
     @PostConstruct
     private void init() {
         hazelcastServiceTest.waitAvailable();
         clientCodeImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
-
-        // Словари для теста, применяются в ValidationConfig
+        tradingClearingRegistryListImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
         putToDictionary(IMDGDistributedNames.Map_WorkflowStatusDictionary, new WorkflowStatusDictionary(), "ACTV");
+        putToDictionary(IMDGDistributedNames.Map_ServiceStatusDictionary, new ServiceStatusDictionary(), ServiceStatus.Active.getKey());
         putToDictionary(IMDGDistributedNames.Map_CompanySymbolDictionary, new CompanySymbolDictionary(), "CLRC");
         putToDictionary(IMDGDistributedNames.Map_CorporationSoleTypeDictionary, new CorporationSoleTypeDictionary(), "GDIR");
         putToDictionary(IMDGDistributedNames.Map_CountryCodeDictionary, new CountryCodeDictionary(), "RUS");
@@ -129,7 +136,7 @@ class ClientCodeServiceTest {
         moneyAccount.setId(131L);
         moneyAccount.setAccount("AAAA-4444");
         moneyAccount.setStatus("ACTV");
-        moneyAccount.setCompanyId(COMPANY_ID); // для валидации принадлежности счёта
+        moneyAccount.setCompanyId(COMPANY_ID);
         accounts.insert(moneyAccount);
         ClearingAccount clsAcc = new ClearingAccount();
         clsAcc.setId(moneyAccount.getId());
@@ -141,7 +148,7 @@ class ClientCodeServiceTest {
         depoAccount.setId(132L);
         depoAccount.setAccount("AAAB-44654");
         depoAccount.setStatus("ACTV");
-        depoAccount.setCompanyId(COMPANY_ID); // для валидации принадлежности счёта
+        depoAccount.setCompanyId(COMPANY_ID);
         accounts.insert(depoAccount);
         DepoAccount depoAcc = new DepoAccount();
         depoAcc.setId(depoAccount.getId());
@@ -149,6 +156,14 @@ class ClientCodeServiceTest {
         depoAcc.setAccountId(depoAccount.getId());
         depoAccounts.insert(depoAcc);
 
+        Account c2Account = new Account();
+        c2Account.setId(133L);
+        c2Account.setAccount("AAAX-44654-CURR");
+        c2Account.setStatus("ACTV");
+        c2Account.setCompanyId(COMPANY_ID);
+        c2Account.setAccountType(AccountType.Curr.getKey());
+        accounts.insert(c2Account);
+
         new TestObjectCreator(hazelcastServiceTest).createUserAdmin(1000L);
     }
 
@@ -176,14 +191,8 @@ class ClientCodeServiceTest {
     }
 
 
-    /**
-     * {@link ClientCodeService#clientCodeUpdate(BaseRequest)}<br>
-     * Тест проверяет создание {@link ClientCode} в IMDG при передаче из Apache Kafka (очередь 1).<br>
-     * Входной запрос {@link ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest}:<br>
-     **/
     @Test
     void clientCodeNew1() {
-        //ARRANGE
         final String ccCode = "Lucky planet";
         ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest();
         clientCodeNewRequest.setCompanyId(COMPANY_ID);
@@ -197,31 +206,18 @@ class ClientCodeServiceTest {
         predictableClientCode.setCode(ccCode);
         predictableClientCode.setStatus("ACTV");
         predictableClientCode.setCompanyId(COMPANY_ID);
-//        predictableClientCode.setMoneyAccountId(131L);
-//        predictableClientCode.setDepoAccountId(132L);
-//        predictableClientCode.setTradingClearingRegistryId(TCR_ID);
-
-        //ACT
         String jsonString = TestUtils.getJsonStringForNew(clientCodeNewRequest, ID);
 
         TestUtils.addRecordToKafka((MockConsumer) clientCodeService.getConsumer(), Consts.DESTINATION_CLIENT_CODE_NEW, PARTITION, 0, jsonString);
-
-        //ASSERT
-        waitingSendAndCheckRecord(ID,  mockProducer);
+        waitingSendAndCheckRecord(ID, mockProducer);
         ClientCode resultNew = clientCodeImdg.getFirstObjectBySQL(String.format("code = '%s'", ccCode));
         predictableClientCode.setId(resultNew.getId());
         CLIENT_CODE_MATCHER.assertMatch(resultNew, predictableClientCode);
         assertNotNull(resultNew.getCreated());
     }
 
-    /**
-     * {@link ClientCodeService#clientCodeUpdate(BaseRequest)}<br>
-     * Тест проверяет создание {@link ClientCode} в IMDG при передаче из Apache Kafka (очередь 2).<br>
-     * Входной запрос {@link ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest}:<br>
-     **/
     @Test
     void clientCodeNew2() {
-        //ARRANGE
         final String ccCode = "Lucky planet";
         ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest();
         clientCodeNewRequest.setCompanyId(COMPANY_ID);
@@ -235,17 +231,10 @@ class ClientCodeServiceTest {
         predictableClientCode.setCode(ccCode);
         predictableClientCode.setStatus("ACTV");
         predictableClientCode.setCompanyId(COMPANY_ID);
-//        predictableClientCode.setMoneyAccountId(131L);
-//        predictableClientCode.setDepoAccountId(132L);
-//        predictableClientCode.setTradingClearingRegistryId(TCR_ID);
-
-        //ACT
         String jsonString = TestUtils.getJsonStringForNew(clientCodeNewRequest, ID);
 
         TestUtils.addRecordToKafka((MockConsumer) clientCodeService.getConsumer(), Consts.DESTINATION_CLIENT_CODE_NEW_UM_COMPANY, PARTITION, 0, jsonString);
-
-        //ASSERT
-        TestUtils.waitingSendAndCheckRecord(ID, mockProducer, producerRecord);
+        waitingSendAndCheckRecord(ID, mockProducer, producerRecord);
         ClientCode resultNew = clientCodeImdg.getFirstObjectBySQL(String.format("code = '%s'", ccCode));
         predictableClientCode.setId(resultNew.getId());
         CLIENT_CODE_MATCHER.assertMatch(resultNew, predictableClientCode);
@@ -253,15 +242,8 @@ class ClientCodeServiceTest {
     }
 
 
-    /**
-     * {@link ClientCodeService#clientCodeUpdate(BaseRequest)}<br>
-     * Тест проверяет создание {@link ClientCode} в IMDG при передаче из Apache Kafka (очередь 1).<br>
-     * NEW с заполненными MoneyAccountId(131L), DepoAccountId(132L); - от этого будет создан ТКР.
-     * Входной запрос {@link ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest}:<br>
-     **/
     @Test
     void clientCodeNew3() {
-        //ARRANGE
         final String ccCode = "Lucky planet2";
         ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest();
         clientCodeNewRequest.setCompanyId(COMPANY_ID);
@@ -278,13 +260,9 @@ class ClientCodeServiceTest {
         predictableClientCode.setMoneyAccountId(131L);
         predictableClientCode.setDepoAccountId(132L);
         predictableClientCode.setTradingClearingRegistryId(TCR_ID);
-
-        //ACT
         String jsonString = TestUtils.getJsonStringForNew(clientCodeNewRequest, ID);
 
         TestUtils.addRecordToKafka((MockConsumer) clientCodeService.getConsumer(), Consts.DESTINATION_CLIENT_CODE_NEW, PARTITION, 0, jsonString);
-
-        //ASSERT
         waitingSendAndCheckRecord(ID, mockProducer);
         ClientCode resultNew = clientCodeImdg.getFirstObjectBySQL(String.format("code = '%s'", ccCode));
         predictableClientCode.setId(resultNew.getId());
@@ -292,14 +270,43 @@ class ClientCodeServiceTest {
         assertNotNull(resultNew.getCreated());
     }
 
-    /**
-     * {@link ClientCodeService#clientCodeUpdate(BaseRequest)}<br>
-     * Тест проверяет обновление сущности {@link ClientCode} в IMDG при передаче из Apache Kafka.<br>
-     * Входной запрос {@link ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeUpdateRequest}:<br>
-     **/
+
+    @Test
+    void clientCodeNew4() {
+        final String ccCode = "Lucky";
+        ClientCodeNewRequest clientCodeNewRequest = new ClientCodeNewRequest();
+        clientCodeNewRequest.setCompanyId(COMPANY_ID);
+        clientCodeNewRequest.setCode(ccCode);
+        clientCodeNewRequest.setTradingClearingRegistryId(TCR_ID);
+        clientCodeNewRequest.setMoneyAccountId(131L);
+        clientCodeNewRequest.setDepoAccountId(132L);
+        clientCodeNewRequest.setCurrencyAccountList(Arrays.asList(133L));
+        clientCodeNewRequest.setStatus("ACTV");
+
+        ClientCode predictableClientCode = new ClientCode();
+        predictableClientCode.setCode(ccCode);
+        predictableClientCode.setStatus("ACTV");
+        predictableClientCode.setCompanyId(COMPANY_ID);
+        predictableClientCode.setMoneyAccountId(131L);
+        predictableClientCode.setDepoAccountId(132L);
+        predictableClientCode.setCurrencyAccountId(133L);
+        predictableClientCode.setTradingClearingRegistryId(TCR_ID);
+        String jsonString = TestUtils.getJsonStringForNew(clientCodeNewRequest, ID);
+
+        TestUtils.addRecordToKafka((MockConsumer) clientCodeService.getConsumer(), Consts.DESTINATION_CLIENT_CODE_NEW, PARTITION, 0, jsonString);
+        waitingSendAndCheckRecord(ID, mockProducer);
+        ClientCode resultNew = clientCodeImdg.getFirstObjectBySQL(String.format("code = '%s'", ccCode));
+        predictableClientCode.setId(resultNew.getId());
+        CLIENT_CODE_MATCHER.assertMatch(resultNew, predictableClientCode);
+        assertNotNull(resultNew.getCreated());
+
+        TradingClearingRegistryList newTCRList = tradingClearingRegistryListImdg.getFirstObjectBySQL("accountId=" + predictableClientCode.getCurrencyAccountId());
+        assertNotNull(newTCRList);
+        assertEquals(TCR_ID, newTCRList.getTradingClearingRegistryId());
+    }
+
     @Test
     void clientCodeUpdate() {
-        //ARRANGE
         ClientCode existsClientCode = new ClientCode();
         existsClientCode.setId(ID);
         existsClientCode.setCompanyId(COMPANY_ID);
@@ -327,13 +334,9 @@ class ClientCodeServiceTest {
         predictableClientCode.setMoneyAccountId(131L);
         predictableClientCode.setDepoAccountId(132L);
         predictableClientCode.setStatus("ACTV");
-
-        //ACT
         String jsonString = TestUtils.getJsonStringForUpdate(clientCodeUpdateRequest, ID);
 
         TestUtils.addRecordToKafka((MockConsumer) clientCodeService.getConsumer(), Consts.DESTINATION_CLIENT_CODE_UPDATE, PARTITION, 0, jsonString);
-
-        //ASSERT
         waitingSendAndCheckRecord(ID, mockProducer);
 
         ClientCode resultUpdating = clientCodeImdg.getSingleObjectByID(ID);
@@ -342,19 +345,12 @@ class ClientCodeServiceTest {
     }
 
 
-    /**
-     * {@link ClientCodeService#clientCodeUpdate(BaseRequest)}<br>
-     * Тест проверяет удаление {@link ClientCode} из IMDG при передаче из Apache Kafka.<br>
-     * Входной запрос {@link ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest}:<br>
-     **/
     @Test
     void clientCodeDelete1() {
-        //ARRANGE
         ClientCode existsClientCode = new ClientCode();
         existsClientCode.setId(ID);
         existsClientCode.setCompanyId(COMPANY_ID);
         existsClientCode.setCode("0000");
-        // Если следующие поля заполнить, то дополнительно отправит сообщение в trading-clearing-registry-update:
         existsClientCode.setTradingClearingRegistryId(null);
         existsClientCode.setMoneyAccountId(null);
         existsClientCode.setDepoAccountId(null);
@@ -365,56 +361,14 @@ class ClientCodeServiceTest {
         CommonDeleteRequest clientCodeDeleteRequest = new CommonDeleteRequest();
         clientCodeDeleteRequest.setId(ID);
 
-        Assertions.assertNotNull(clientCodeImdg.getSingleObjectByID(ID)); // verify test data
-
-        //ACT
+        assertNotNull(clientCodeImdg.getSingleObjectByID(ID));
         String jsonString = TestUtils.getJsonStringForUpdate(clientCodeDeleteRequest, ID);
 
         TestUtils.addRecordToKafka((MockConsumer) clientCodeService.getConsumer(), Consts.DESTINATION_CLIENT_CODE_DELETE, PARTITION, 0, jsonString);
 
-        //ASSERT
-
         waitingSendAndCheckRecord(ID, mockProducer);
         ClientCode resultUpdate = clientCodeImdg.getSingleObjectByID(ID);
         assertEquals(WorkflowStatus.Blocked.getKey(), resultUpdate.getStatus());
     }
 
-//    /**
-//     * {@link ClientCodeService#clientCodeUpdate(BaseRequest)}<br>
-//     * Тест проверяет удаление {@link ClientCode} из IMDG при передаче из Apache Kafka.<br>
-//     * У ClientCode заполнены MoneyAccountId, DepoAccountId - по этому при удалении должно направиться дополнительное сообщение в очередь DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE<br>
-//     * Входной запрос {@link ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest}:<br>
-//     **/
-//    @Test
-//    void clientCodeDelete2() {
-//        //ARRANGE
-//        ClientCode existsClientCode = new ClientCode();
-//        existsClientCode.setId(ID);
-//        existsClientCode.setCompanyId(COMPANY_ID);
-//        existsClientCode.setCode("0000");
-//        // Если следующие поля заполнить, то дополнительно отправит сообщение в trading-clearing-registry-update:
-//        existsClientCode.setTradingClearingRegistryId(TCR_ID);
-//        existsClientCode.setMoneyAccountId(131L);
-//        existsClientCode.setDepoAccountId(132L);
-//        existsClientCode.setStatus("ACTV");
-//
-//        clientCodeImdg.insert(existsClientCode);
-//
-//        CommonDeleteRequest clientCodeDeleteRequest = new CommonDeleteRequest();
-//        clientCodeDeleteRequest.setId(ID);
-//
-//        Assertions.assertNotNull(clientCodeImdg.getSingleObjectByID(ID)); // verify test data
-//
-//        //ACT
-//        String jsonString = getJsonStringForUpdate(clientCodeDeleteRequest, ID);
-//
-//        addRecordToKafka((MockConsumer) clientCodeService.getConsumer(), Consts.DESTINATION_CLIENT_CODE_DELETE, PARTITION, 0, jsonString);
-//
-//        //ASSERT
-//
-//        waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
-//        ClientCode resultUpdate = clientCodeImdg.getSingleObjectByID(ID);
-//        Assertions.assertNull(resultUpdate);
-//    }
-
 }

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java

@@ -124,6 +124,7 @@ class InformationAccountServiceTest {
         Account accountAnlt = new Account();
         accountAnlt.setAccountType(AccountType.Anlt.getKey());
         accountAnlt.setCompanyId(1L);
+        accountAnlt.setCurrency("RUB");
         anltAccountId = accountImdg.insert(accountAnlt);
 
         new TestObjectCreator(hazelcastServiceTest).createUserAdmin(1000L);
@@ -134,6 +135,7 @@ class InformationAccountServiceTest {
         InformationAccountNewRequest InformationAccountNewRequest = new InformationAccountNewRequest();
         InformationAccountNewRequest.setCompanyId(companyId);
         InformationAccountNewRequest.setAccount(account);
+        InformationAccountNewRequest.setCurrency(null);
 
         String jsonString = getJsonStringForNew(InformationAccountNewRequest, 0L);
 
@@ -172,27 +174,35 @@ class InformationAccountServiceTest {
 
     @Test
     void accountIncrementSequence() {
-        Imdg<InformationAccount> accountInfoImdg = hazelcastServiceTest.getImdg( IMDGDistributedNames.Map_InformationAccount, InformationAccount.class );
+        Imdg<InformationAccount> accountInfoImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class);
 
         {
             Account account = new Account();
             account.setId(120L);
             account.setAccountType(AccountType.Info.getKey());
+            account.setCurrency(CurrencyCode.RUB.getKey());
             account.setCompanyId(10L);
             account.setAccount("39911810000000127000");
             accountImdg.insert(account);
             InformationAccount accountInfo = new InformationAccount();
             accountInfo.setId(121L);
+            account.setCurrency(CurrencyCode.RUB.getKey());
             accountInfo.setAccountId(account.getId());
             accountInfo.setCompanyId(account.getCompanyId());
             accountInfoImdg.insert(accountInfo);
         }
         UserRoleVerification userRoleVerification = Mockito.mock(UserRoleVerification.class);
-        InformationAccountService infoAccSvc=new InformationAccountService(null,null,null,
-                null, userRoleVerification, hazelcastServiceTest, null, null, null, null);
-        Long n = infoAccSvc.accountNextId();
+        InformationAccountService infoAccSvc = new InformationAccountService(null, null, null,
+            null, userRoleVerification, hazelcastServiceTest, null, null, null, null);
+        Long n = infoAccSvc.accountNextId(null);
         Assertions.assertEquals(13L, n);
-        n = infoAccSvc.accountNextId();
+        n = infoAccSvc.accountNextId(null);
         Assertions.assertEquals(14L, n);
+        n = infoAccSvc.accountNextId(CurrencyCode.RUB.getKey());
+        Assertions.assertEquals(15L, n);
+        n = infoAccSvc.accountNextId("CNY");
+        Assertions.assertEquals(2L, n);
+        n = infoAccSvc.accountNextId("CNY");
+        Assertions.assertEquals(3L, n);
     }
 }

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryListServiceTest.java

@@ -0,0 +1,255 @@
+package ru.spcex.clearing.account.service;
+
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.junit.jupiter.api.Assertions;
+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.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.ClientCode;
+import ru.clearing.classes.statics.data.account.DepoAccount;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.profile.CompanyInfo;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+import ru.clearing.platform.dictionary.*;
+import ru.spcex.clearing.account.config.BeanConfiguration;
+import ru.spcex.clearing.account.config.validation.ClientCodeValidationConfig;
+import ru.spcex.clearing.account.config.validation.TradingClearingRegistryListValidationConfig;
+import ru.spcex.clearing.account.config.validation.TradingClearingRegistryValidationConfig;
+import ru.spcex.clearing.account.config.validation.ValidationConfig;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeUpdateRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListUpdateRequest;
+import ru.spcex.clearing.test.MatcherFactory;
+import ru.spcex.clearing.test.TestObjectCreator;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.ServiceStatus;
+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 java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static ru.spcex.clearing.test.TestUtils.waitingSendAndCheckRecord;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+    TradingClearingRegistryListService.class,
+    TradingClearingRegistryListValidationConfig.class,
+    ClientCodeService.class,
+    ClientCodeValidationConfig.class,
+
+    TradingClearingRegistryService.class,
+    TradingClearingRegistryValidationConfig.class,
+
+    ValidationConfig.class,
+    BeanConfiguration.class,
+
+    KafkaTestConfig.class,
+    ImdgTestConfig.class})
+class TradingClearingRegistryListServiceTest {
+    private static final int PARTITION = 0;
+    private static final Long ID = 4L;
+    public static final MatcherFactory.Matcher<ClientCode> CLIENT_CODE_MATCHER = MatcherFactory.usingIgnoringFieldsComparator("created", "updated");
+    public static final MatcherFactory.Matcher<TradingClearingRegistryList> TRADING_CLEARING_REGISTRY_LIST_MATCHER = MatcherFactory.usingIgnoringFieldsComparator("created", "updated");
+
+    private static final Long TCR_ID = 41L;
+    private static final Long COMPANY_ID = 42L;
+
+    @Autowired
+    TradingClearingRegistryListService tradingClearingRegistryListService;
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private HazelcastService hazelcastServiceTest;
+    @Captor
+    private ArgumentCaptor<ProducerRecord> producerRecord;
+    @Autowired
+    @Qualifier("mockProducer")
+    protected Producer<String, Object> mockProducer;
+
+    private Imdg<ClientCode> clientCodeImdg;
+    private Imdg<TradingClearingRegistryList> tradingClearingRegistryListImdg;
+
+    @PostConstruct
+    private void init() {
+        hazelcastServiceTest.waitAvailable();
+        clientCodeImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
+        tradingClearingRegistryListImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+        putToDictionary(IMDGDistributedNames.Map_WorkflowStatusDictionary, new WorkflowStatusDictionary(), "ACTV");
+        putToDictionary(IMDGDistributedNames.Map_ServiceStatusDictionary, new ServiceStatusDictionary(), ServiceStatus.Active.getKey());
+        putToDictionary(IMDGDistributedNames.Map_CompanySymbolDictionary, new CompanySymbolDictionary(), "CLRC");
+        putToDictionary(IMDGDistributedNames.Map_CorporationSoleTypeDictionary, new CorporationSoleTypeDictionary(), "GDIR");
+        putToDictionary(IMDGDistributedNames.Map_CountryCodeDictionary, new CountryCodeDictionary(), "RUS");
+        putToDictionary(IMDGDistributedNames.Map_AllowedDictionary, new AllowedDictionary(), "ALWD");
+        putToDictionary(IMDGDistributedNames.Map_LegalKindDictionary, new LegalKindDictionary(), "JURD");
+        putToDictionary(IMDGDistributedNames.Map_OrganizationTypeDictionary, new OrganizationTypeDictionary(), "NCRD");
+
+
+        Imdg<Company> companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        Company company1 = new Company();
+        company1.setId(COMPANY_ID);
+        company1.setWorkflowStatus(WorkflowStatus.Active.getKey());
+        company1.setFullName("Company prime");
+        company1.setShortName("Seizwell");
+        company1.setProfile(new CompanyInfo());
+        company1.getProfile().setCompanyId(COMPANY_ID);
+        company1.getProfile().setCountryCode("TLDI");
+        company1.getProfile().setDescription("Big profit from TLD Company Prime.");
+        company1.getProfile().setLegalKind("TLDI");
+        company1.getProfile().setResidence("TLDI");
+        companyImdg.insert(company1);
+
+        Imdg<TradingClearingRegistry> tcrImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+        TradingClearingRegistry registry1 = new TradingClearingRegistry();
+        registry1.setId(TCR_ID);
+        registry1.setCompanyId(COMPANY_ID);
+        registry1.setCode("code-120-101");
+        registry1.setMoneyAccountId(131L);
+        registry1.setDepoAccountId(132L);
+        registry1.setTradingClearingRegistryType(TradingClearingRegistryType.Client_B.getKey());
+        registry1.setStatus(WorkflowStatus.Active.getKey());
+        tcrImdg.insert(registry1);
+
+        Imdg<Account> accounts = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        Imdg<ClearingAccount> clsAccounts = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
+        Account moneyAccount = new Account();
+        moneyAccount.setId(131L);
+        moneyAccount.setAccount("AAAA-4444");
+        moneyAccount.setStatus("ACTV");
+        moneyAccount.setCompanyId(COMPANY_ID);
+        accounts.insert(moneyAccount);
+        ClearingAccount clsAcc = new ClearingAccount();
+        clsAcc.setId(moneyAccount.getId());
+        clsAcc.setCompanyId(COMPANY_ID);
+        clsAcc.setAccountId(moneyAccount.getId());
+        clsAccounts.insert(clsAcc);
+        Imdg<DepoAccount> depoAccounts = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
+        Account depoAccount = new Account();
+        depoAccount.setId(132L);
+        depoAccount.setAccount("AAAB-44654");
+        depoAccount.setStatus("ACTV");
+        depoAccount.setCompanyId(COMPANY_ID);
+        accounts.insert(depoAccount);
+        DepoAccount depoAcc = new DepoAccount();
+        depoAcc.setId(depoAccount.getId());
+        depoAcc.setCompanyId(COMPANY_ID);
+        depoAcc.setAccountId(depoAccount.getId());
+        depoAccounts.insert(depoAcc);
+
+        Account c2Account = new Account();
+        c2Account.setId(133L);
+        c2Account.setAccount("AAAX-44654-CURR");
+        c2Account.setStatus("ACTV");
+        c2Account.setCompanyId(COMPANY_ID);
+        c2Account.setAccountType(AccountType.Info.getKey());
+        c2Account.setCurrency("USD");
+        accounts.insert(c2Account);
+
+        Account c3Account = new Account();
+        c3Account.setId(134L);
+        c3Account.setAccount("AAAX-12654-CURR");
+        c3Account.setStatus("ACTV");
+        c3Account.setCompanyId(COMPANY_ID);
+        c3Account.setAccountType(AccountType.Info.getKey());
+        c3Account.setCurrency("USD");
+        accounts.insert(c3Account);
+
+        new TestObjectCreator(hazelcastServiceTest).createUserAdmin(1000L);
+    }
+
+    private <D extends AbstractDictionary> void putToDictionary(String mapName, D object, String code) {
+        Imdg<D> dMap = (Imdg) hazelcastServiceTest.getImdg(mapName, object.getClass());
+        object.setId(2L);
+        object.setCode(code);
+        object.setName("name of " + code);
+        dMap.insert(object);
+    }
+
+
+    @Test
+    void tradingClearingRegistryListNew() {
+        final String ccCode = null;
+        TradingClearingRegistryListNewRequest tcrlNewRequest = new TradingClearingRegistryListNewRequest();
+        tcrlNewRequest.setTradingClearingRegistryId(TCR_ID);
+        tcrlNewRequest.setAccountId(134L);
+        tcrlNewRequest.setStatus("ACTV");
+
+        ClientCode predictableClientCode = new ClientCode();
+        predictableClientCode.setCode(ccCode);
+        predictableClientCode.setStatus("ACTV");
+        predictableClientCode.setCompanyId(COMPANY_ID);
+
+        TradingClearingRegistryList predictableTradingClearingRegistryList = new TradingClearingRegistryList();
+        predictableTradingClearingRegistryList.setAccountId(134L);
+        predictableTradingClearingRegistryList.setStatus("ACTV");
+        predictableTradingClearingRegistryList.setCurrency("USD");
+        String jsonString = TestUtils.getJsonStringForNew(tcrlNewRequest, ID);
+
+        TestUtils.addRecordToKafka((MockConsumer) tradingClearingRegistryListService.getConsumer(), Consts.DESTINATION_TRADING_CLEARING_REGISTRIES_LIST_NEW, PARTITION, 0, jsonString);
+        waitingSendAndCheckRecord(ID, mockProducer);
+        ClientCode resultCCNew = clientCodeImdg.getFirstObjectBySQL(String.format("code = '%s'", ccCode));
+        predictableClientCode.setId(resultCCNew.getId());
+        CLIENT_CODE_MATCHER.assertMatch(resultCCNew, predictableClientCode);
+        assertNotNull(resultCCNew.getCreated());
+
+        TradingClearingRegistryList resultTCRLNew = tradingClearingRegistryListImdg.getFirstObjectBySQL(String.format("code = '%s'", ccCode));
+        predictableClientCode.setId(resultTCRLNew.getId());
+        TRADING_CLEARING_REGISTRY_LIST_MATCHER.assertMatch(resultTCRLNew, predictableTradingClearingRegistryList);
+        assertNotNull(resultTCRLNew.getCreated());
+        tradingClearingRegistryListImdg.delete(resultTCRLNew);
+    }
+
+    @Test
+    void tradingClearingRegistryListUpdate() {
+        TradingClearingRegistryList existsTradingClearingRegistryList = new TradingClearingRegistryList();
+        existsTradingClearingRegistryList.setId(ID);
+        existsTradingClearingRegistryList.setTradingClearingRegistryId(TCR_ID);
+        existsTradingClearingRegistryList.setCurrency("BTC");
+        existsTradingClearingRegistryList.setAccountId(133L);
+        tradingClearingRegistryListImdg.insert(existsTradingClearingRegistryList);
+
+        TradingClearingRegistryListUpdateRequest tradingClearingRegistryListUpdateRequest = new TradingClearingRegistryListUpdateRequest();
+        tradingClearingRegistryListUpdateRequest.setId(ID);
+        tradingClearingRegistryListUpdateRequest.setTradingClearingRegistryId(TCR_ID);
+        tradingClearingRegistryListUpdateRequest.setStatus("ACTV");
+        tradingClearingRegistryListUpdateRequest.setCurrencyAccountList(Arrays.asList(134L));
+
+        TradingClearingRegistryList predictableTradingClearingRegistryList = new TradingClearingRegistryList();
+        predictableTradingClearingRegistryList.setId(ID);
+        predictableTradingClearingRegistryList.setTradingClearingRegistryId(TCR_ID);
+        predictableTradingClearingRegistryList.setCurrency("BTC");
+        predictableTradingClearingRegistryList.setAccountId(133L);
+        predictableTradingClearingRegistryList.setStatus("ACTV");
+        String jsonString = TestUtils.getJsonStringForUpdate(tradingClearingRegistryListUpdateRequest, ID);
+
+        TestUtils.addRecordToKafka((MockConsumer) tradingClearingRegistryListService.getConsumer(), Consts.DESTINATION_TRADING_CLEARING_REGISTRIES_LIST_UPDATE, PARTITION, 0, jsonString);
+        waitingSendAndCheckRecord(ID, mockProducer);
+
+        TradingClearingRegistryList resultUpdating = tradingClearingRegistryListImdg.getSingleObjectByID(ID);
+        TRADING_CLEARING_REGISTRY_LIST_MATCHER.assertMatch(resultUpdating, predictableTradingClearingRegistryList);
+        assertNotNull(resultUpdating.getUpdated());
+        tradingClearingRegistryListImdg.delete(resultUpdating);
+    }
+
+}

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/TradingClearingRegistryServiceTest.java

@@ -283,15 +283,11 @@ class TradingClearingRegistryServiceTest {
         tradingClearingRegistryUpdateRequest.setId(registryId);
 
         String jsonString = getJsonStringForUpdate(tradingClearingRegistryUpdateRequest, 0);
-
-        //ACT
         addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
-                Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE,
-                PARTITION,
-                0,
-                jsonString);
-
-        //ASSERT
+            Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE,
+            PARTITION,
+            0,
+            jsonString);
         waitingSendAndCheckRecord(0L, mockProducer);
 
         TradingClearingRegistry resultUpdating = tradingClearingRegistryImdg.getSingleObjectByID(registryId);
@@ -311,15 +307,11 @@ class TradingClearingRegistryServiceTest {
         tradingClearingRegistryDeleteRequest.setId(registryId);
 
         String jsonString = getJsonStringForDelete(tradingClearingRegistryDeleteRequest, 0);
-
-        //ACT
         addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
-                Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK,
-                PARTITION,
-                0,
-                jsonString);
-
-        //ASSERT
+            Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK,
+            PARTITION,
+            0,
+            jsonString);
         waitingSendAndCheckRecord(0L, mockProducer);
 
         TradingClearingRegistry resultUpdating = tradingClearingRegistryImdg.getSingleObjectByID(registryId);

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/UtilsTest.java

@@ -0,0 +1,45 @@
+package ru.spcex.clearing.account.service;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.Test;
+import ru.clearing.classes.statics.data.account.Account;
+
+public class UtilsTest {
+
+    @Test
+    public void testAccount() {
+        Long currencyCodeId = 1L;
+        String withTrailingZero = String.format("%03d", currencyCodeId);
+        String withTrailingZero2 = "%d%03d%08d%d".formatted(39911, currencyCodeId, 1, 7000);
+        List<Account> allInfoAcc = new ArrayList<>();
+        Account account = new Account();
+        account.setAccount("39911051000000027000");
+        allInfoAcc.add(account);
+        Pattern accPattern = Pattern.compile("39911%s([0-9]{8})7000".formatted(withTrailingZero));
+        int maxN = 1;
+        int parsedCount = 0;
+        String lastAccount = null;
+        for (Account acc : allInfoAcc) {
+            try {
+                String number = acc.getAccount();
+                if (StringUtils.isEmpty(number)) continue;
+                lastAccount = number;
+                Matcher m = accPattern.matcher(number);
+                if (m.find()) {
+                    String seqNumber = m.group(1);
+                    if (StringUtils.isNotEmpty(seqNumber)) {
+                        int accN = Integer.parseInt(seqNumber);
+                        if (accN > maxN) maxN = accN;
+                    }
+                    parsedCount++;
+                }
+            } catch (Exception errParse) {
+            }
+        }
+    }
+}

clearing-parent/backend-api/pom.xml

@@ -11,7 +11,7 @@
     <parent>
         <artifactId>clearing-parent</artifactId>
         <groupId>ru.spcex.clearing</groupId>
-        <version>SPCEX-1.0.0.0</version>
+        <version>SPCEX-3.12.2</version>
     </parent>
 
 
@@ -61,6 +61,17 @@
             <groupId>ru.spcex.platform</groupId>
             <artifactId>platform-enum</artifactId>
         </dependency>
+        <!-- special logging -->
+        <dependency>
+            <groupId>net.logstash.logback</groupId>
+            <artifactId>logstash-logback-encoder</artifactId>
+            <version>7.0.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
         <!-- TEST -->
         <dependency>
             <groupId>org.springframework</groupId>
@@ -208,6 +219,19 @@
                                         </fileMapper>
                                     </fileMappers>
                                 </transformationSet>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>market.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/data.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>market.sql</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
                             </transformationSets>
                         </configuration>
                     </execution>

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/BackendApiApplication.java

@@ -26,7 +26,6 @@ public class BackendApiApplication extends SpringBootServletInitializer {
     @Override
     protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
         setKeycloakConfigFile();
-        //        springApplicationBuilder.initializers(DfaConfig.get().getLoggingInitializer());
         return builder.sources(BackendApiApplication.class);
     }
 
@@ -35,9 +34,6 @@ public class BackendApiApplication extends SpringBootServletInitializer {
         return super.run(application);
     }
 
-    /**
-     * чтобы переместить настройки keycloak в keycloak.json вместо application.properties
-     */
     private static void setKeycloakConfigFile() {
         System.setProperty("keycloak.configurationFile", "classpath:keycloak.json");
     }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/BackEndApiImdgConfig.java

@@ -47,9 +47,8 @@ public class BackEndApiImdgConfig {
             throw new IllegalArgumentException("Property \"backend-api.hazelcast.cluster-members\" not set");
         }
         ImdgProvider imdg = new HazelcastService(taskExecutorHazelcastClientInitializer,
-                taskExecutorIdGeneratorAwaiter,
-                clientSetting.getHazelcast());
-// todo корректное ожидание готовности        imdg.waitAvailable();
+            taskExecutorIdGeneratorAwaiter,
+            clientSetting.getHazelcast());
         return imdg;
     }
 
@@ -62,12 +61,10 @@ public class BackEndApiImdgConfig {
     ) {
         if (clientSetting.getHazelcastSearch() == null || clientSetting.getHazelcastSearch().getClusterMembers() == null) {
             log.warn("Property \"backend-api.hazelcast-search.cluster-members\" not set!");
-            // может работать без history, но history будет недоступна
         }
         ImdgProvider imdg = new HazelcastService(taskExecutorHazelcastClientInitializer,
-                taskExecutorIdGeneratorAwaiter,
-                clientSetting.getHazelcastSearch());
-// todo корректное ожидание готовности        imdg.waitAvailable();
+            taskExecutorIdGeneratorAwaiter,
+            clientSetting.getHazelcastSearch());
         return imdg;
     }
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java

@@ -40,6 +40,7 @@ public class HistoryConfig {
         hst.add(excludeLiabilitiesRegister());
         hst.add(liabilitiesRegister());
         hst.add(executionRegister());
+        hst.add(session());
         return hst;
     }
 
@@ -174,4 +175,17 @@ public class HistoryConfig {
         ));
         return sbscr;
     }
+
+
+    private HistorySubscription session() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("session");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchSession);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_Session);
+        sbscr.setConditions(List.of(
+                new ClearingDateFromCondition(pb),
+                new ClearingDateToCondition(pb)
+        ));
+        return sbscr;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/WebConfig.java

@@ -22,7 +22,6 @@ import java.util.function.Consumer;
 @SuppressWarnings("Duplicates")
 @Configuration
 @EnableWebMvc
-//todo remove? see ClearingCorsFilter
 @CrossOrigin
 public class WebConfig implements WebMvcConfigurer {
     private final MappingJackson2HttpMessageConverter customJsonHttpConverter;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/AbstractQueueController.java

@@ -22,9 +22,6 @@ public abstract class AbstractQueueController {
         return responseToClient;
     }
 
-    /**
-     * Для оптимизации передачи userId
-     */
     protected <T> CudResponse processRequest(String destination, IAction<T> iAction, Long userId) throws ExecutionException, InterruptedException {
         CudResponse responseToClient = new CudResponse();
         responseToClient.setPayload(operator.sendRequestToQueue(destination, iAction, userId));

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/InformationAccountController.java

@@ -44,20 +44,9 @@ public class InformationAccountController extends AbstractQueueController {
     @ResponseBody
     public CommonGetAllResponse getAll() {
         Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_InformationAccount,
-                InformationAccount.class);
+            InformationAccount.class);
         CommonGetAllResponse response = new CommonGetAllResponse();
         response.fromEntity(all);
         return response;
     }
-
-
-//    @ApiOperation(value = "Добавление информационного счета.")
-//    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
-//    @RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
-//    @ResponseBody
-//    public CudResponse add(
-//            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
-//            @RequestBody AccountInformationNewAction accountNewInformationAction) throws ExecutionException, InterruptedException {
-//        return processRequest(Consts.DESTINATION_INFORMATION_ACCOUNT_NEW, accountNewInformationAction);
-//    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/CompanyRoleSetController.java

@@ -12,6 +12,7 @@ import ru.clearing.classes.statics.data.company.CompanyRoleSet;
 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.company.CompanyRoleSetNewAction;
+import ru.spcex.clearing.backendapi.controller.request.cud.company.CompanyRoleSetUpdateAction;
 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;
@@ -30,35 +31,35 @@ public class CompanyRoleSetController extends AbstractQueueController {
     private final IStateLoader stateLoader;
 
     @Autowired
-    public CompanyRoleSetController(IOperator operator,
-                                    IStateLoader stateLoader) {
+    public CompanyRoleSetController(IOperator operator, IStateLoader stateLoader) {
         super(operator);
         this.stateLoader = stateLoader;
     }
 
-    @ApiOperation(value = "get all CompanyRoleSet's.")
-    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
-    @RequestMapping(method = RequestMethod.GET)
-    @ResponseBody
-    public CommonGetAllResponse getAll() {
-        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_CompanyRoleSet,
-                CompanyRoleSet.class);
-        CommonGetAllResponse response = new CommonGetAllResponse();
-        response.fromEntity(all);
-        return response;
-    }
-
-    @ApiOperation(value = "create CompanyRoleSet.")
+    @ApiOperation(value = "new company-role-set.")
     @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
-    @RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)
+    @RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
     @ResponseBody
-    public CudResponse create(
-            @ApiParam(value = "Значения полей нового объекта.", required = true)
+    public CudResponse add(
+            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
             @RequestBody CompanyRoleSetNewAction companyRoleSetNewAction) throws ExecutionException, InterruptedException {
-        return processRequest(Consts.DESTINATION_COMPANY_ROLE_SET_NEW, companyRoleSetNewAction);
+        return processRequest(Consts.DESTINATION_COMPANY_ROLE_SETS_NEW, companyRoleSetNewAction);
     }
 
-    @ApiOperation(value = "delete CompanyRoleSet.")
+    @ApiOperation(value = "update company-role-set.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse update(
+            @ApiParam(value = "Идентификатор изменяемого объекта.", required = true, example = "1234")
+            @PathVariable("id") Long id,
+            @ApiParam(value = "Новые значения полей объекта.", required = true)
+            @RequestBody CompanyRoleSetUpdateAction companyRoleSetUpdateAction) throws ExecutionException, InterruptedException {
+        companyRoleSetUpdateAction.setId(id);
+        return processRequest(Consts.DESTINATION_COMPANY_ROLE_SETS_UPDATE, companyRoleSetUpdateAction);
+    }
+
+    @ApiOperation(value = "delete company-role-set.")
     @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class)})
     @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
     @ResponseBody
@@ -66,7 +67,17 @@ public class CompanyRoleSetController extends AbstractQueueController {
                               @PathVariable("id") Long id) throws ExecutionException, InterruptedException {
         CommonDeleteAction deleteAction = new CommonDeleteAction();
         deleteAction.setId(id);
-        return processRequest(Consts.DESTINATION_COMPANY_ROLE_SET_DELETE, deleteAction);
+        return processRequest(Consts.DESTINATION_COMPANY_ROLE_SETS_DELETE, deleteAction);
     }
 
+    @ApiOperation(value = "get all company-role-sets.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/SettlementHousePropertiesController.java

@@ -0,0 +1,83 @@
+package ru.spcex.clearing.backendapi.controller.queue.company;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+import ru.clearing.classes.statics.data.company.SettlementHouseProperties;
+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.company.SettlementHousePropertiesNewAction;
+import ru.spcex.clearing.backendapi.controller.request.cud.company.SettlementHousePropertiesUpdateAction;
+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;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+@Controller
+@RequestMapping("/settlement-house-properties")
+public class SettlementHousePropertiesController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public SettlementHousePropertiesController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "new settlement-house-property.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse add(
+            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+            @RequestBody SettlementHousePropertiesNewAction settlementHousePropertiesNewAction) throws ExecutionException, InterruptedException {
+        return processRequest(Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_NEW, settlementHousePropertiesNewAction);
+    }
+
+    @ApiOperation(value = "update settlement-house-property.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse update(
+            @ApiParam(value = "Идентификатор изменяемого объекта.", required = true, example = "1234")
+            @PathVariable("id") Long id,
+            @ApiParam(value = "Новые значения полей объекта.", required = true)
+            @RequestBody SettlementHousePropertiesUpdateAction settlementHousePropertyUpdateAction) throws ExecutionException, InterruptedException {
+        settlementHousePropertyUpdateAction.setId(id);
+        return processRequest(Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_UPDATE, settlementHousePropertyUpdateAction);
+    }
+
+    @ApiOperation(value = "delete settlement-house-property.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class)})
+    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public CudResponse delete(@ApiParam(value = "Идентификатор удаляемого объекта", required = true, example = "1234")
+                              @PathVariable("id") Long id) throws ExecutionException, InterruptedException {
+        CommonDeleteAction deleteAction = new CommonDeleteAction();
+        deleteAction.setId(id);
+        return processRequest(Consts.DESTINATION_SETTLEMENT_HOUSE_PROPERTY_DELETE, deleteAction);
+    }
+
+    @ApiOperation(value = "get all SettlementHouseProperties.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_SettlementHouseProperties, SettlementHouseProperties.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/execution/ExecutionCurrencyController.java

@@ -0,0 +1,56 @@
+package ru.spcex.clearing.backendapi.controller.queue.execution;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.execution.ExecutionCurrency;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+
+import java.time.LocalDate;
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/execution-currency")
+public class ExecutionCurrencyController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+    private final ImdgPredicateBuilder imdgPredicateBuilder;
+
+    @Autowired
+    public ExecutionCurrencyController(IOperator operator,
+                                       IStateLoader stateLoader,
+                                       ImdgProvider imdgProvider) {
+        super(operator);
+        this.stateLoader = stateLoader;
+        this.imdgPredicateBuilder = imdgProvider
+                .getImdg(IMDGDistributedNames.Map_ExecutionCurrency, ExecutionCurrency.class)
+                .predicateBuilder();
+    }
+
+    @ApiOperation(value = "get all ExecutionCurrency.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        ImdgPredicate imdgPredicate = imdgPredicateBuilder.greatEqual("settlementDate", LocalDate.now());
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_ExecutionCurrency,
+                ExecutionCurrency.class,
+                imdgPredicate);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java

@@ -66,10 +66,9 @@ public class HistController {
         }
 
         Optional<Class<? extends SpcexObjectBase>> entityClass = responseFactory.classByDestination(destination);
-        //class may be added to HistorySubscription if needed
         if (entityClass.isEmpty()) {
             throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError,
-                    "destination " + "'" + destination + "' not supported (meta class not found)"));
+                "destination " + "'" + destination + "' not supported (meta class not found)"));
         }
 
         HistoryRequest req = new HistoryRequest();
@@ -82,10 +81,10 @@ public class HistController {
         conditionProvider.conditionForRequest(req).map(s -> subscr[0] = s, p -> prdct[0] = p);
 
         Collection<Map<String, Object>> searchRes = stateLoader.getAllMetaTransform(
-                subscr[0].getSearchProxyMapName(),
-                subscr[0].getFullHistoryMapName(),
-                entityClass.get(),
-                prdct[0]
+            subscr[0].getSearchProxyMapName(),
+            subscr[0].getFullHistoryMapName(),
+            entityClass.get(),
+            prdct[0]
         );
 
         CommonGetAllResponse response = new CommonGetAllResponse();

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java

@@ -58,7 +58,6 @@ public class ConditionProvider {
 
         ImdgPredicate result;
         if (predicates.size() == 0) {
-            //add boundary conditions?
             log.warn("destination '{}' zero predicates found", destination);
             result = pb.alwaysTrue();
         } else if (predicates.size() == 1) {

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/HistorySubscription.java

@@ -9,7 +9,6 @@ public class HistorySubscription {
     private List<IHistoryCondition> conditions;
     private String searchProxyMapName;
     private String fullHistoryMapName;
-    //class
 
 
     public List<IHistoryCondition> getConditions() {

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/SCrossRateController.java

@@ -0,0 +1,43 @@
+package ru.spcex.clearing.backendapi.controller.queue.misc;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.misc.SCrossRate;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/cross-rate")
+public class SCrossRateController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public SCrossRateController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all cross-rate's.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_SCrossRate, SCrossRate.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/GatewayResultController.java

@@ -0,0 +1,41 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+import ru.clearing.classes.statics.data.register.GatewayResult;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/gateway-result")
+public class GatewayResultController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public GatewayResultController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all pair-sdf.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_GatewayResult, GatewayResult.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/PairSdfController.java

@@ -0,0 +1,41 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+import ru.clearing.classes.statics.data.register.PairSdf;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/pair-sdf")
+public class PairSdfController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public PairSdfController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all pair-sdf.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_PairSdf, PairSdf.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/RegistryController.java

@@ -4,10 +4,13 @@ import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponses;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.*;
+import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
 import ru.spcex.clearing.backendapi.controller.request.cud.registry.*;
@@ -18,7 +21,12 @@ import ru.spcex.clearing.backendapi.service.IOperator;
 import ru.spcex.clearing.backendapi.service.IStateLoader;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.platform.enumeration.RegistryDesignation;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 
+import java.time.LocalDate;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
@@ -26,12 +34,17 @@ import java.util.concurrent.ExecutionException;
 @Controller
 @RequestMapping("/registries")
 public class RegistryController extends AbstractQueueController {
+    protected final Logger log = LoggerFactory.getLogger(getClass());
     private final IStateLoader stateLoader;
+    private final ImdgPredicateBuilder predicateBuilder;
 
     @Autowired
-    public RegistryController(IOperator operator, IStateLoader stateLoader) {
+    public RegistryController(IOperator operator, IStateLoader stateLoader, ImdgProvider imdgProvider) {
         super(operator);
         this.stateLoader = stateLoader;
+        this.predicateBuilder = imdgProvider
+                .getImdg(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class)
+                .predicateBuilder();
     }
 
     @ApiOperation(value = "get all registries.")
@@ -39,7 +52,19 @@ public class RegistryController extends AbstractQueueController {
     @RequestMapping(method = RequestMethod.GET)
     @ResponseBody
     public CommonGetAllResponse getAll() {
-        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Registry, Registry.class);
+        ImdgPredicate filter = predicateBuilder.or(
+            predicateBuilder.equals("registryDesignation", RegistryDesignation.A.getKey()),
+            predicateBuilder.equals("registryDesignation", RegistryDesignation.D.getKey()),
+            predicateBuilder.and(
+                predicateBuilder.or(
+                    predicateBuilder.equals("registryDesignation", RegistryDesignation.O.getKey()),
+                    predicateBuilder.equals("registryDesignation", RegistryDesignation.T.getKey())
+                ),
+                predicateBuilder.greatEqual("settlementDate", LocalDate.now())
+            )
+        );
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Registry, Registry.class,
+            filter);
         CommonGetAllResponse response = new CommonGetAllResponse();
         response.fromEntity(all);
         return response;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryListController.java

@@ -0,0 +1,73 @@
+package ru.spcex.clearing.backendapi.controller.queue.registry;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryListNewAction;
+import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryListUpdateAction;
+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;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+@Controller
+@RequestMapping("/trading-clearing-registries-list")
+public class TradingClearingRegistryListController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public TradingClearingRegistryListController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all TradingClearingRegistryList's")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+            IMDGDistributedNames.Map_TradingClearingRegistryList,
+            TradingClearingRegistryList.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+
+    @ApiOperation(value = "Добавление списка счетов ТКР")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse add(
+        @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+        @RequestBody TradingClearingRegistryListNewAction tradingClearingRegistryListNewAction) throws ExecutionException, InterruptedException {
+        return processRequest(Consts.DESTINATION_TRADING_CLEARING_REGISTRIES_LIST_NEW, tradingClearingRegistryListNewAction);
+    }
+
+    @ApiOperation(value = "Изменение списка счетов ТКР")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse update(
+        @ApiParam(value = "Идентификатор изменяемого объекта.", required = true, example = "1234")
+        @PathVariable("id") Long id,
+        @ApiParam(value = "Новые значения полей объекта.", required = true)
+        @RequestBody TradingClearingRegistryListUpdateAction tradingClearingRegistryListUpdateAction) throws ExecutionException, InterruptedException {
+        tradingClearingRegistryListUpdateAction.setId(id);
+        return processRequest(Consts.DESTINATION_TRADING_CLEARING_REGISTRIES_LIST_UPDATE, tradingClearingRegistryListUpdateAction);
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/LauncherController.java

@@ -86,8 +86,6 @@ public class LauncherController extends AbstractQueueController {
         }
         launcherCommand.setTask(dictionaryName);
         launcherCommand.setUserId(user.getId());
-        //топики ограничиваются наличием в taskDictionary
-        //подписываются на разные топики в разных модулях, см. ru.spcex.platform.enumeration.Task#topic
         return processRequest(Consts.LAUNCHER_NEW, launcherCommand);
     }
 
@@ -104,9 +102,9 @@ public class LauncherController extends AbstractQueueController {
         if (taskEnum == null) {
             throw new NotFound404Exception("task dictionary element with code '" + launcherNew.getTask() + "'");
         }
-        if (!IEnumKey.contains(taskEnum.getCode(), Task.startOfClearing, Task.dbfExport_OUTV)) {
+        if (!IEnumKey.contains(taskEnum.getCode(), Task.startOfClearing, Task.dbfExport_OUTV, Task.getAllBalance, Task.createRegistry_GBRR)) {
             log.warn(String.format("Task %s not support request with body", taskEnum.getCode()));
-        } // else В мете эти модели с дополнительными параметрами (OUTV).
+        }
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
         String username = KeycloakUtils.getUserNameFromAuthentication(authentication);
         User user = userImdg.getFirstObjectByFieldValues(Map.of("identifier", username));

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/sdf/SdfsController.java

@@ -237,6 +237,19 @@ public class SdfsController extends AbstractQueueController {
         return response;
     }
 
+    @ApiOperation(value = "get all S_DF51")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(value = "s-df51", method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAllSdf51() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_SDf51,
+                SDf51.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+
     @ApiOperation(value = "get all S_DF52")
     @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
     @RequestMapping(value = "s-df52", method = RequestMethod.GET)

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CurrencyPairSecurityController.java

@@ -0,0 +1,84 @@
+package ru.spcex.clearing.backendapi.controller.queue.securities;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
+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.securities.CurrencyPairSecurityNewAction;
+import ru.spcex.clearing.backendapi.controller.request.cud.securities.CurrencyPairSecurityUpdateAction;
+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;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+@Controller
+@RequestMapping("/securities/currency-pair-securities")
+public class CurrencyPairSecurityController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public CurrencyPairSecurityController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "create currencyPairSecurity.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse add(
+            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+            @RequestBody CurrencyPairSecurityNewAction currencyPairSecurityNewAction) throws ExecutionException, InterruptedException {
+        return processRequest(Consts.DESTINATION_CURRENCY_PAIR_SECURITIES_NEW, currencyPairSecurityNewAction);
+    }
+
+    @ApiOperation(value = "update currencyPairSecurity.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse update(
+            @ApiParam(value = "Идентификатор изменяемого объекта.", required = true, example = "1234")
+            @PathVariable("id") Long id,
+            @ApiParam(value = "Новые значения полей объекта.", required = true)
+            @RequestBody CurrencyPairSecurityUpdateAction currencyPairSecurityUpdateAction) throws ExecutionException, InterruptedException {
+        currencyPairSecurityUpdateAction.setId(id);
+        return processRequest(Consts.DESTINATION_CURRENCY_PAIR_SECURITIES_UPDATE, currencyPairSecurityUpdateAction);
+    }
+
+    @ApiOperation(value = "delete currency pair securities.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public CudResponse delete(@ApiParam(value = "Идентификатор удаляемого объекта", required = true, example = "1234")
+                              @PathVariable("id") Long id) throws ExecutionException, InterruptedException {
+        CommonDeleteAction deleteAction = new CommonDeleteAction();
+        deleteAction.setId(id);
+        return processRequest(Consts.DESTINATION_CURRENCY_PAIR_SECURITIES_DELETE, deleteAction);
+    }
+
+    @ApiOperation(value = "get all equity securities.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_CurrencyPairSecurity,
+                CurrencyPairSecurity.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java

@@ -20,9 +20,6 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;
 
-/**
- * SecurityController и MoneyMarketSecurityController разные контроллеры, не путать.
- */
 @Controller
 @RequestMapping("/securities")
 public class SecurityController {
@@ -40,13 +37,16 @@ public class SecurityController {
     public CommonGetAllResponse getAll() {
         Collection<Map<String, Object>> all = new ArrayList<>();
         all.addAll(stateLoader.getAllMetaTransformSpecificClass(
-                IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class
+            IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class
         ));
         all.addAll(stateLoader.getAllMetaTransformSpecificClass(
-                IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class
+            IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class
         ));
         all.addAll(stateLoader.getAllMetaTransformSpecificClass(
-                IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class
+            IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class
+        ));
+        all.addAll(stateLoader.getAllMetaTransformSpecificClass(
+            IMDGDistributedNames.Map_CurrencyPairSecurity, EquitySecurity.class
         ));
         CommonGetAllResponse response = new CommonGetAllResponse();
         response.fromEntity(all);

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java

@@ -90,10 +90,6 @@ public class UserController extends AbstractQueueController {
             log.warn("user {} sended update request for user {}", username, userUpdateAction.getUsername());
             throw new IllegalStateException("cannot perform delete action for " + username);
         }
-//        User user = userImdg.getSingleObjectByFieldValues(Map.of("identifier", username));
-//        if (user == null) {
-//            log.info("update user {} authenticated, but User object was not created", username);
-//        }
         return processRequest(Consts.USER_UPDATE, userUpdateAction);
     }
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/StatementController.java

@@ -58,8 +58,6 @@ public class StatementController extends AbstractQueueController {
         Optional<Statement> statement = stateLoader.getById(id, IMDGDistributedNames.Map_Statement, Statement.class);
         CommonGetByIdResponse response = new CommonGetByIdResponse();
         if (statement.isEmpty()) {
-            //можно так, либо response.setCode(404); response.setMessage("blabla"); но тогда еще нужно
-            //отдельно HTTP статус проставлять
             throw new NotFound404Exception(String.valueOf(id));
         }
         Statement stmt = statement.get();

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/AccountInformationNewAction.java

@@ -17,6 +17,9 @@ public class AccountInformationNewAction implements IAction<InformationAccountNe
     @ApiModelProperty(value = "Наименование статуса", example = "ACTV")
     @JsonProperty
     private String status;
+    @ApiModelProperty(value = "Код валюты", example = "RUB")
+    @JsonProperty
+    public String currency;
     @ApiModelProperty(value = "Наименование типа счета", example = "INFO")
     @JsonProperty
     private String accountType;
@@ -26,6 +29,7 @@ public class AccountInformationNewAction implements IAction<InformationAccountNe
         var req = new InformationAccountNewRequest();
         req.setCompanyId(this.companyId);
         req.setAccount(this.account);
+        req.setCurrency(this.currency);
         req.setStatus(this.status);
         req.setAccountType(this.accountType);
         return req;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/AccountNewAction.java

@@ -29,6 +29,9 @@ public class AccountNewAction implements IAction<AccountNewRequest> {
     @ApiModelProperty(value = "Наименование типа счета", example = "CLRN")
     @JsonProperty
     private String accountType;
+    @ApiModelProperty(value = "Код валюты", example = "RUB")
+    @JsonProperty
+    private String currency;
 
     @Override
     public AccountNewRequest toRequest() {
@@ -37,6 +40,7 @@ public class AccountNewAction implements IAction<AccountNewRequest> {
         req.setAccount(this.account);
         req.setStatus(this.status);
         req.setAccountType(this.accountType);
+        req.setCurrency(this.currency);
         return req;
     }
 
@@ -77,4 +81,12 @@ public class AccountNewAction implements IAction<AccountNewRequest> {
     public void setAccountType(String accountType) {
         this.accountType = accountType;
     }
+
+    public String getCurrency() {
+        return currency;
+    }
+
+    public void setCurrency(String currency) {
+        this.currency = currency;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java

@@ -47,6 +47,12 @@ public class BankAccountNewAction implements IAction<BankAccountNewRequest> {
     @ApiModelProperty(value = "Компания", example = "1234")
     @JsonProperty
     private Long companyId;
+    @ApiModelProperty(value = "SWIFT", example = "ABCDE")
+    @JsonProperty
+    private String swiftCode;
+    @ApiModelProperty(value = "Код SWIFT посредника", example = "ABCDE")
+    @JsonProperty
+    private String intermediarySwiftCode;
 
     @Override
     public BankAccountNewRequest toRequest() {
@@ -61,6 +67,8 @@ public class BankAccountNewAction implements IAction<BankAccountNewRequest> {
         req.setTaxRegistrationReasonCode(this.taxRegistrationReasonCode);
         req.setAccount(this.account);
         req.setCompanyId(this.companyId);
+        req.setSwiftCode(swiftCode);
+        req.setIntermediarySwiftCode(intermediarySwiftCode);
         return req;
     }
 
@@ -149,4 +157,20 @@ public class BankAccountNewAction implements IAction<BankAccountNewRequest> {
     public void setCompanyId(Long companyId) {
         this.companyId = companyId;
     }
+
+    public String getSwiftCode() {
+        return swiftCode;
+    }
+
+    public void setSwiftCode(String swiftCode) {
+        this.swiftCode = swiftCode;
+    }
+
+    public String getIntermediarySwiftCode() {
+        return intermediarySwiftCode;
+    }
+
+    public void setIntermediarySwiftCode(String intermediarySwiftCode) {
+        this.intermediarySwiftCode = intermediarySwiftCode;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountUpdateAction.java

@@ -38,6 +38,12 @@ public class BankAccountUpdateAction implements IAction<BankAccountUpdateRequest
     @ApiModelProperty(value = "Код причины постановки (КПП)", example = "01")
     @JsonProperty
     private String taxRegistrationReasonCode;
+    @ApiModelProperty(value = "SWIFT", example = "ABCDE")
+    @JsonProperty
+    private String swiftCode;
+    @ApiModelProperty(value = "Код SWIFT посредника", example = "ABCDE")
+    @JsonProperty
+    private String intermediarySwiftCode;
 
     @ApiModelProperty(value = "Номер счета", example = "11111222223333344444")
     private String account;
@@ -55,6 +61,8 @@ public class BankAccountUpdateAction implements IAction<BankAccountUpdateRequest
         req.setTaxpayerIdentificationNumber(this.taxpayerIdentificationNumber);
         req.setTaxRegistrationReasonCode(this.taxRegistrationReasonCode);
         req.setAccount(this.account);
+        req.setSwiftCode(swiftCode);
+        req.setIntermediarySwiftCode(intermediarySwiftCode);
         return req;
     }
 
@@ -143,4 +151,20 @@ public class BankAccountUpdateAction implements IAction<BankAccountUpdateRequest
     public void setAccount(String account) {
         this.account = account;
     }
+
+    public String getSwiftCode() {
+        return swiftCode;
+    }
+
+    public void setSwiftCode(String swiftCode) {
+        this.swiftCode = swiftCode;
+    }
+
+    public String getIntermediarySwiftCode() {
+        return intermediarySwiftCode;
+    }
+
+    public void setIntermediarySwiftCode(String intermediarySwiftCode) {
+        this.intermediarySwiftCode = intermediarySwiftCode;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/ClientCodeNewAction.java

@@ -31,6 +31,9 @@ public class ClientCodeNewAction implements IAction<ClientCodeNewRequest> {
     @ApiModelProperty(value = "Номер депозитарного счета", example = "1234")
     @JsonProperty
     private Long depoAccountId;
+    @ApiModelProperty(value = "Список валютных счетов", example = "[1234,5678]")
+    @JsonProperty
+    private List<Long> currencyAccountList;
     @ApiModelProperty(value = "Наименование статуса", example = "ACTV")
     @JsonProperty
     private String status;
@@ -43,6 +46,7 @@ public class ClientCodeNewAction implements IAction<ClientCodeNewRequest> {
         req.setTradingClearingRegistryId(this.tradingClearingRegistryId);
         req.setMoneyAccountId(this.moneyAccountId);
         req.setDepoAccountId(this.depoAccountId);
+        req.setCurrencyAccountList(this.currencyAccountList);
         req.setStatus(this.status);
         return req;
     }
@@ -93,6 +97,14 @@ public class ClientCodeNewAction implements IAction<ClientCodeNewRequest> {
         this.depoAccountId = depoAccountId;
     }
 
+    public List<Long> getCurrencyAccountList() {
+        return currencyAccountList;
+    }
+
+    public void setCurrencyAccountList(List<Long> currencyAccountList) {
+        this.currencyAccountList = currencyAccountList;
+    }
+
     public String getStatus() {
         return status;
     }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/ClientCodeUpdateAction.java

@@ -32,6 +32,9 @@ public class ClientCodeUpdateAction implements IAction<ClientCodeUpdateRequest>
     @ApiModelProperty(value = "Номер депозитарного счета", example = "1234")
     @JsonProperty
     private Long depoAccountId;
+    @ApiModelProperty(value = "Список валютных счетов", example = "[1234,5678]")
+    @JsonProperty
+    private List<Long> currencyAccountList;
     @ApiModelProperty(value = "Наименование статуса", example = "ACTV")
     @JsonProperty
     private String status;
@@ -46,6 +49,7 @@ public class ClientCodeUpdateAction implements IAction<ClientCodeUpdateRequest>
         req.setTradingClearingRegistryId(this.tradingClearingRegistryId);
         req.setMoneyAccountId(this.moneyAccountId);
         req.setDepoAccountId(this.depoAccountId);
+        req.setCurrencyAccountList(this.currencyAccountList);
         req.setStatus(this.status);
         return req;
     }
@@ -104,6 +108,14 @@ public class ClientCodeUpdateAction implements IAction<ClientCodeUpdateRequest>
         this.depoAccountId = depoAccountId;
     }
 
+    public List<Long> getCurrencyAccountList() {
+        return currencyAccountList;
+    }
+
+    public void setCurrencyAccountList(List<Long> currencyAccountList) {
+        this.currencyAccountList = currencyAccountList;
+    }
+
     public String getStatus() {
         return status;
     }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/company/CompanyRoleSetUpdateAction.java

@@ -0,0 +1,71 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.company;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.company.CompanyRoleSetUpdateRequest;
+
+public class CompanyRoleSetUpdateAction implements IAction<CompanyRoleSetUpdateRequest> {
+    @ApiModelProperty(hidden = true)
+    @JsonProperty
+    public Long id;
+
+    @ApiModelProperty(value = "Наименование компании", example = "1234")
+    @JsonProperty
+    Long companyId;
+    @ApiModelProperty(value = "Код роли компании", example = "ABCD")
+    @JsonProperty
+    String companyRole;
+    @ApiModelProperty(value = "Код статуса", example = "ACTV")
+    @JsonProperty
+    String workflowStatus;
+
+    @Override
+    public CompanyRoleSetUpdateRequest toRequest() {
+        var request = new CompanyRoleSetUpdateRequest();
+        request.setId(this.id);
+        request.setCompanyId(this.companyId);
+        request.setCompanyRole(this.companyRole);
+        request.setWorkflowStatus(this.workflowStatus);
+        return request;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.UPDATE;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getCompanyId() {
+        return companyId;
+    }
+
+    public void setCompanyId(Long companyId) {
+        this.companyId = companyId;
+    }
+
+    public String getCompanyRole() {
+        return companyRole;
+    }
+
+    public void setCompanyRole(String companyRole) {
+        this.companyRole = companyRole;
+    }
+
+    public String getWorkflowStatus() {
+        return workflowStatus;
+    }
+
+    public void setWorkflowStatus(String workflowStatus) {
+        this.workflowStatus = workflowStatus;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/company/SettlementHousePropertiesNewAction.java

@@ -0,0 +1,46 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.company;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.company.SettlementHousePropertyNewRequest;
+
+public class SettlementHousePropertiesNewAction implements IAction<SettlementHousePropertyNewRequest> {
+    @ApiModelProperty(value = "Наименование компании", example = "1234")
+    @JsonProperty
+    Long companyId;
+    @ApiModelProperty(value = "Код валюты", example = "RUB")
+    @JsonProperty
+    String currencyCode;
+
+    @Override
+    public SettlementHousePropertyNewRequest toRequest() {
+        SettlementHousePropertyNewRequest request = new SettlementHousePropertyNewRequest();
+        request.setCompanyId(this.companyId);
+        request.setCurrencyCode(this.currencyCode);
+        return request;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.NEW;
+    }
+
+    public Long getCompanyId() {
+        return companyId;
+    }
+
+    public void setCompanyId(Long companyId) {
+        this.companyId = companyId;
+    }
+
+    public String getCurrencyCode() {
+        return currencyCode;
+    }
+
+    public void setCurrencyCode(String currencyCode) {
+        this.currencyCode = currencyCode;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/company/SettlementHousePropertiesUpdateAction.java

@@ -0,0 +1,60 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.company;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.company.SettlementHousePropertyUpdateRequest;
+
+
+public class SettlementHousePropertiesUpdateAction implements IAction<SettlementHousePropertyUpdateRequest> {
+    @ApiModelProperty(hidden = true)
+    @JsonProperty
+    private Long id;
+    @ApiModelProperty(value = "Наименование компании", example = "1234")
+    @JsonProperty
+    Long companyId;
+    @ApiModelProperty(value = "Код валюты", example = "RUB")
+    @JsonProperty
+    String currencyCode;
+
+    @Override
+    public SettlementHousePropertyUpdateRequest toRequest() {
+        SettlementHousePropertyUpdateRequest request = new SettlementHousePropertyUpdateRequest();
+        request.setId(this.id);
+        request.setCompanyId(this.companyId);
+        request.setCurrencyCode(this.currencyCode);
+        return request;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.UPDATE;
+    }
+
+    @ApiModelProperty(hidden = true)
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getCompanyId() {
+        return companyId;
+    }
+
+    public void setCompanyId(Long companyId) {
+        this.companyId = companyId;
+    }
+
+    public String getCurrencyCode() {
+        return currencyCode;
+    }
+
+    public void setCurrencyCode(String currencyCode) {
+        this.currencyCode = currencyCode;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/registry/TradingClearingRegistryListNewAction.java

@@ -0,0 +1,48 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.registry;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListNewRequest;
+
+import java.util.List;
+
+public class TradingClearingRegistryListNewAction implements IAction<TradingClearingRegistryListNewRequest> {
+    @ApiModelProperty(value = "Торгово-клиринговый регистр", example = "1200")
+    @JsonProperty
+    private Long tradingClearingRegistryId;
+    @ApiModelProperty(value = "Идентификатор валютного счёта", example = "123")
+    @JsonProperty
+    private Long accountId;
+
+    @Override
+    public TradingClearingRegistryListNewRequest toRequest() {
+        var req = new TradingClearingRegistryListNewRequest();
+        req.setTradingClearingRegistryId(this.tradingClearingRegistryId);
+        req.setAccountId(this.accountId);
+        return req;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.NEW;
+    }
+
+    public Long getTradingClearingRegistryId() {
+        return tradingClearingRegistryId;
+    }
+
+    public void setTradingClearingRegistryId(Long tradingClearingRegistryId) {
+        this.tradingClearingRegistryId = tradingClearingRegistryId;
+    }
+
+    public Long getAccountId() {
+        return accountId;
+    }
+
+    public void setAccountId(Long accountId) {
+        this.accountId = accountId;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/registry/TradingClearingRegistryListUpdateAction.java

@@ -0,0 +1,50 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.registry;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryListUpdateRequest;
+
+import java.util.List;
+
+public class TradingClearingRegistryListUpdateAction implements IAction<TradingClearingRegistryListUpdateRequest> {
+
+    @ApiModelProperty(hidden = true)
+    @JsonProperty
+    public Long id;
+    @ApiModelProperty(value = "Наименование статуса", example = "ACTV")
+    @JsonProperty
+    private String status;
+
+
+    @Override
+    public TradingClearingRegistryListUpdateRequest toRequest() {
+        var req = new TradingClearingRegistryListUpdateRequest();
+        req.setId(this.id);
+        req.setStatus(this.status);
+        return req;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.UPDATE;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/LauncherNew.java

@@ -1,15 +1,23 @@
 package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import io.swagger.annotations.ApiModelProperty;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
 import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
+import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalTimeDeserializer;
+import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalTimeSerializer;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 
 import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalTime;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -63,6 +71,24 @@ public class LauncherNew implements IAction<Object> {
     @ApiModelProperty(value = "Наименование счета получателя", example = "1000")
     @JsonProperty
     private Long debitLeg_accountId;
+    @ApiModelProperty(value = "SWIFT", example = "ABCDE")
+    @JsonProperty
+    private String swiftCode;
+
+    @ApiModelProperty(value = "Время", dataType = "java.lang.String", example = "16:30:00")
+    @JsonSerialize(using = LocalTimeSerializer.class)
+    @JsonDeserialize(using = LocalTimeDeserializer.class)
+    @JsonProperty
+    public LocalTime fromTime;
+
+    @ApiModelProperty(value = "Дата с", example = "2024-01-02")
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    @JsonProperty
+    public LocalDate fromDate;
+    @ApiModelProperty(value = "Дата по", example = "2024-03-02")
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    @JsonProperty
+    public LocalDate toDate;
 
     @Override
     public Object toRequest() {
@@ -83,6 +109,10 @@ public class LauncherNew implements IAction<Object> {
         taskRunnerCommandRequest.setCreditLeg_accountId(creditLeg_accountId);
         taskRunnerCommandRequest.setAddresseeId(addresseeId);
         taskRunnerCommandRequest.setDebitLeg_accountId(debitLeg_accountId);
+        taskRunnerCommandRequest.setFromTime(fromTime);
+        taskRunnerCommandRequest.setSwiftCode(swiftCode);
+        taskRunnerCommandRequest.setFromDate(fromDate);
+        taskRunnerCommandRequest.setToDate(toDate);
         return taskRunnerCommandRequest;
     }
 
@@ -220,6 +250,14 @@ public class LauncherNew implements IAction<Object> {
         this.debitLeg_accountId = debitLeg_accountId;
     }
 
+    public String getSwiftCode() {
+        return swiftCode;
+    }
+
+    public void setSwiftCode(String swiftCode) {
+        this.swiftCode = swiftCode;
+    }
+
     public BigDecimal getFullBalance() {
         return fullBalance;
     }
@@ -227,4 +265,28 @@ public class LauncherNew implements IAction<Object> {
     public void setFullBalance(BigDecimal fullBalance) {
         this.fullBalance = fullBalance;
     }
+
+    public LocalTime getFromTime() {
+        return fromTime;
+    }
+
+    public void setFromTime(LocalTime fromTime) {
+        this.fromTime = fromTime;
+    }
+
+    public LocalDate getFromDate() {
+        return fromDate;
+    }
+
+    public void setFromDate(LocalDate fromDate) {
+        this.fromDate = fromDate;
+    }
+
+    public LocalDate getToDate() {
+        return toDate;
+    }
+
+    public void setToDate(LocalDate toDate) {
+        this.toDate = toDate;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/CurrencyPairSecurityNewAction.java

@@ -0,0 +1,135 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.securities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityNewRequest;
+import ru.spcex.platform.classes.base.interfaces.WithSecuritySymbol;
+
+import java.math.BigDecimal;
+
+public class CurrencyPairSecurityNewAction implements IAction<CurrencyPairSecurityNewRequest>, WithSecuritySymbol {
+    @ApiModelProperty(value = "Наименование типа инструмента", example = "CDE")
+    @JsonProperty
+    public String instrumentType;
+    @ApiModelProperty(value = "Код инструмента", example = "CDE")
+    @JsonProperty
+    public String securitySymbol;
+    @ApiModelProperty(value = "Краткое наименование инструмента", example = "NAME")
+    @JsonProperty
+    public String shortName;
+    @ApiModelProperty(value = "Полное наименование инструмента", example = "NAME of NAME")
+    @JsonProperty
+    public String fullName;
+    @ApiModelProperty(value = "Валютная пара", example = "1234")
+    @JsonProperty
+    public Long currencyPairId;
+    @ApiModelProperty(value = "Количество валюты лота", example = "12.33")
+    @JsonProperty
+    public BigDecimal baseUnitSize;
+    @ApiModelProperty(value = "Наименование статуса", example = "CDE")
+    @JsonProperty
+    public String settlementType;
+    @ApiModelProperty(value = "Наименование статуса", example = "CDE")
+    @JsonProperty
+    public String workflowStatus;
+    @ApiModelProperty(value = "Наименование клиринговой организации", example = "NAME")
+    @JsonProperty
+    public String clearingOrganization;
+
+    @Override
+    public CurrencyPairSecurityNewRequest toRequest() {
+        var req = new CurrencyPairSecurityNewRequest();
+        req.setInstrumentType(this.getInstrumentType());
+        req.setSecuritySymbol(this.getSecuritySymbol());
+        req.setShortName(this.getShortName());
+        req.setFullName(this.getFullName());
+        req.setCurrencyPairId(this.getCurrencyPairId());
+        req.setBaseUnitSize(this.getBaseUnitSize());
+        req.setSettlementType(this.getSettlementType());
+        req.setWorkflowStatus(this.getWorkflowStatus());
+        req.setClearingOrganization(this.getClearingOrganization());
+
+        return req;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.NEW;
+    }
+
+    public String getInstrumentType() {
+        return instrumentType;
+    }
+
+    public void setInstrumentType(String instrumentType) {
+        this.instrumentType = instrumentType;
+    }
+
+    @Override
+    public String getSecuritySymbol() {
+        return securitySymbol;
+    }
+
+    public void setSecuritySymbol(String securitySymbol) {
+        this.securitySymbol = securitySymbol;
+    }
+
+    public String getShortName() {
+        return shortName;
+    }
+
+    public void setShortName(String shortName) {
+        this.shortName = shortName;
+    }
+
+    public String getFullName() {
+        return fullName;
+    }
+
+    public void setFullName(String fullName) {
+        this.fullName = fullName;
+    }
+
+    public Long getCurrencyPairId() {
+        return currencyPairId;
+    }
+
+    public void setCurrencyPairId(Long currencyPairId) {
+        this.currencyPairId = currencyPairId;
+    }
+
+    public BigDecimal getBaseUnitSize() {
+        return baseUnitSize;
+    }
+
+    public void setBaseUnitSize(BigDecimal baseUnitSize) {
+        this.baseUnitSize = baseUnitSize;
+    }
+
+    public String getSettlementType() {
+        return settlementType;
+    }
+
+    public void setSettlementType(String settlementType) {
+        this.settlementType = settlementType;
+    }
+
+    public String getWorkflowStatus() {
+        return workflowStatus;
+    }
+
+    public void setWorkflowStatus(String workflowStatus) {
+        this.workflowStatus = workflowStatus;
+    }
+
+    public String getClearingOrganization() {
+        return clearingOrganization;
+    }
+
+    public void setClearingOrganization(String clearingOrganization) {
+        this.clearingOrganization = clearingOrganization;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/CurrencyPairSecurityUpdateAction.java

@@ -0,0 +1,148 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.securities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.security.CurrencyPairSecurityUpdateRequest;
+import ru.spcex.platform.classes.base.interfaces.WithId;
+
+import java.math.BigDecimal;
+
+public class CurrencyPairSecurityUpdateAction implements IAction<CurrencyPairSecurityUpdateRequest>, WithId {
+    @ApiModelProperty(hidden = true)
+    @JsonProperty
+    public Long id;
+
+    @ApiModelProperty(value = "Наименование типа инструмента", example = "CDE")
+    @JsonProperty
+    public String instrumentType;
+    @ApiModelProperty(value = "Код инструмента", example = "CDE")
+    @JsonProperty
+    public String securitySymbol;
+    @ApiModelProperty(value = "Краткое наименование инструмента", example = "NAME")
+    @JsonProperty
+    public String shortName;
+    @ApiModelProperty(value = "Полное наименование инструмента", example = "NAME of NAME")
+    @JsonProperty
+    public String fullName;
+    @ApiModelProperty(value = "Валютная пара", example = "1234")
+    @JsonProperty
+    public Long currencyPairId;
+    @ApiModelProperty(value = "Количество валюты лота", example = "12.33")
+    @JsonProperty
+    public BigDecimal baseUnitSize;
+    @ApiModelProperty(value = "Наименование статуса", example = "CDE")
+    @JsonProperty
+    public String settlementType;
+    @ApiModelProperty(value = "Наименование статуса", example = "CDE")
+    @JsonProperty
+    public String workflowStatus;
+    @ApiModelProperty(value = "Наименование клиринговой организации", example = "NAME")
+    @JsonProperty
+    public String clearingOrganization;
+
+    @Override
+    public CurrencyPairSecurityUpdateRequest toRequest() {
+        var req = new CurrencyPairSecurityUpdateRequest();
+        req.setId(this.getId());
+        req.setInstrumentType(this.getInstrumentType());
+        req.setSecuritySymbol(this.getSecuritySymbol());
+        req.setShortName(this.getShortName());
+        req.setFullName(this.getFullName());
+        req.setCurrencyPairId(this.getCurrencyPairId());
+        req.setBaseUnitSize(this.getBaseUnitSize());
+        req.setSettlementType(this.getSettlementType());
+        req.setWorkflowStatus(this.getWorkflowStatus());
+        req.setClearingOrganization(this.getClearingOrganization());
+        return req;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.UPDATE;
+    }
+
+
+    @Override
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getInstrumentType() {
+        return instrumentType;
+    }
+
+    public void setInstrumentType(String instrumentType) {
+        this.instrumentType = instrumentType;
+    }
+
+    public String getSecuritySymbol() {
+        return securitySymbol;
+    }
+
+    public void setSecuritySymbol(String securitySymbol) {
+        this.securitySymbol = securitySymbol;
+    }
+
+    public String getShortName() {
+        return shortName;
+    }
+
+    public void setShortName(String shortName) {
+        this.shortName = shortName;
+    }
+
+    public String getFullName() {
+        return fullName;
+    }
+
+    public void setFullName(String fullName) {
+        this.fullName = fullName;
+    }
+
+    public Long getCurrencyPairId() {
+        return currencyPairId;
+    }
+
+    public void setCurrencyPairId(Long currencyPairId) {
+        this.currencyPairId = currencyPairId;
+    }
+
+    public BigDecimal getBaseUnitSize() {
+        return baseUnitSize;
+    }
+
+    public void setBaseUnitSize(BigDecimal baseUnitSize) {
+        this.baseUnitSize = baseUnitSize;
+    }
+
+    public String getSettlementType() {
+        return settlementType;
+    }
+
+    public void setSettlementType(String settlementType) {
+        this.settlementType = settlementType;
+    }
+
+    public String getWorkflowStatus() {
+        return workflowStatus;
+    }
+
+    public void setWorkflowStatus(String workflowStatus) {
+        this.workflowStatus = workflowStatus;
+    }
+
+    public String getClearingOrganization() {
+        return clearingOrganization;
+    }
+
+    public void setClearingOrganization(String clearingOrganization) {
+        this.clearingOrganization = clearingOrganization;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/company/CompanyBackendGetAll.java

@@ -51,25 +51,6 @@ public class CompanyBackendGetAll extends BasicSpcexResponse {
             singleItem.setFullName(company.getFullName());
             singleItem.setCreated(company.getCreated());
             singleItem.setUpdated(company.getUpdated());
-//            CompanyInfo profile = company.getProfile();
-//            if (profile != null) {
-//                singleItem.setCorporationSoleType(profile.getCorporationSoleType());
-//                singleItem.setCountryCode(profile.getCountryCode());
-//                singleItem.setDescription(profile.getDescription());
-//                singleItem.setProfessionalSign(profile.getProfessionalSign());
-//                singleItem.setLegalKind(profile.getLegalKind());
-//                singleItem.setOrganizationType(profile.getOrganizationType());
-//                singleItem.setResidence(profile.getResidence());
-//                singleItem.setShortNameEng(profile.getShortNameEng());
-//                singleItem.setFullNameEng(profile.getFullNameEng());
-//            }
-            /* todo
-                CompanySymbol companySymbol = ;
-                if (companySymbol!=null) {
-
-            singleItem.setCompanySymbol(profile.getCompanySymbol());
-            singleItem.setCompanySymbolValue(profile.getCompanySymbolValue());
-        }*/
 
             payload.getItems().add(singleItem);
         }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/registry/TradingClearingRegistryBackendGetById.java

@@ -6,12 +6,6 @@ import io.swagger.annotations.ApiModelProperty;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
 
-/**
- * Банковские реквизиты для перечисления денежных средств
- *
- * @ApiModel(description = "Ответ в результате отправки операции в топик Kafka.")
- * @ApiModelProperty(value = "Информация о принятом запросе")
- **/
 @ApiModel(description = "Ответ при получении объекта TradingClearingRegistry.")
 public class TradingClearingRegistryBackendGetById extends BasicSpcexResponse {
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/system/RequestInfoResponse.java

@@ -9,11 +9,6 @@ import ru.spcex.clearing.platform.messaging.domain.json.serialize.EnumSerializer
 import ru.spcex.clearing.platform.messaging.service.Status;
 
 
-/**
- * Банковские реквизиты для перечисления денежных средств
- * @ApiModel(description = "Ответ в результате отправки операции в топик Kafka.")
- * @ApiModelProperty(value = "Информация о принятом запросе")
- **/
 @ApiModel(description = "Ответ при получении статуса запроса.")
 public class RequestInfoResponse extends BasicSpcexResponse {
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/AnyKafkaMessageAction.java

@@ -0,0 +1,60 @@
+package ru.spcex.clearing.backendapi.controller.test;
+
+import io.swagger.annotations.ApiModelProperty;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonRawValue;
+import com.fasterxml.jackson.databind.JsonNode;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
+
+public class AnyKafkaMessageAction implements IAction<TradingClearingRegistryNewRequest> {
+    @ApiModelProperty(value = "полное имя класса payload для BaseRequest", example = "ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest")
+    @JsonProperty
+    private String fullClassName;
+    @JsonProperty
+    private String topicName;
+    @JsonRawValue
+    public String json;
+
+    @JsonProperty("json")
+    private void unpackRawJson(JsonNode json) {
+        this.json = json.toString();
+    }
+
+    @Override
+    public TradingClearingRegistryNewRequest toRequest() {
+        var req = new TradingClearingRegistryNewRequest();
+        return req;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.SYSTEM;
+    }
+
+    public String getFullClassName() {
+        return fullClassName;
+    }
+
+    public void setFullClassName(String fullClassName) {
+        this.fullClassName = fullClassName;
+    }
+
+    public String getTopicName() {
+        return topicName;
+    }
+
+    public void setTopicName(String topicName) {
+        this.topicName = topicName;
+    }
+
+    public String getJson() {
+        return json;
+    }
+
+    public void setJson(String json) {
+        this.json = json;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/KafkaApiController.java

@@ -0,0 +1,67 @@
+package ru.spcex.clearing.backendapi.controller.test;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Controller;
+import org.springframework.util.ClassUtils;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.spcex.clearing.backendapi.errors.BackEndError;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.error.ValidationException;
+import ru.spcex.platform.utils.text.TextUtil;
+
+@Profile("dev")
+@Controller
+@RequestMapping("/anonymous/kafka-api")
+public class KafkaApiController {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final KafkaSender kafkaSender;
+    private static final ObjectMapper json = new ObjectMapper();
+
+    @Autowired
+    public KafkaApiController(KafkaSender kafkaSender) {
+        this.kafkaSender = kafkaSender;
+    }
+
+    @ApiOperation(value = "Test backend-api availability.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = String.class)})
+    @RequestMapping(method = RequestMethod.POST, path = "/any/message", produces = MediaType.TEXT_PLAIN_VALUE)
+    @ResponseBody
+    public String processGet(@ApiParam(value = "Параметры команды в JSON формате.", required = true)
+            @RequestBody AnyKafkaMessageAction bankAccountNewAction) throws ClassNotFoundException, ValidationException, JsonProcessingException {
+        log.info("Call test method for backend-api controller");
+        validate(bankAccountNewAction);
+        Class<?> parameterType = ClassUtils.forName(bankAccountNewAction.getFullClassName(), ClassUtils.getDefaultClassLoader());
+        JavaType requestType = json.getTypeFactory().constructSimpleType(parameterType, null);
+        Object obj = json.readValue(bankAccountNewAction.getJson(), requestType);
+        Long idOfBaseRequestMessage = kafkaSender.sendRequestToQueue(bankAccountNewAction.getTopicName(), obj);
+        return "success: baseRequest.id = " + idOfBaseRequestMessage;
+    }
+
+    private void validate(AnyKafkaMessageAction bankAccountNewAction) throws ValidationException {
+        if (TextUtil.isEmpty(bankAccountNewAction.getTopicName())) {
+            throw new ValidationException(new EnumMessage(BackEndError.ValidationError, "topicName"));
+        }
+        if (TextUtil.isEmpty(bankAccountNewAction.getFullClassName())) {
+            throw new ValidationException(new EnumMessage(BackEndError.ValidationError, "fullClassName"));
+        }
+        if (TextUtil.isEmpty(bankAccountNewAction.getJson())) {
+            throw new ValidationException(new EnumMessage(BackEndError.ValidationError, "json"));
+        }
+    }
+
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/RevalMapAction.java

@@ -0,0 +1,22 @@
+package ru.spcex.clearing.backendapi.controller.test;
+
+import io.swagger.annotations.ApiModelProperty;
+import java.util.List;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public class RevalMapAction {
+    @ApiModelProperty(
+        value = "мапы для перезагрузки",
+        example = "Map_Registry"
+    )
+    @JsonProperty
+    private List<String> maps;
+
+    public List<String> getMaps() {
+        return maps;
+    }
+
+    public void setMaps(List<String> maps) {
+        this.maps = maps;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/RevalMapController.java

@@ -0,0 +1,69 @@
+package ru.spcex.clearing.backendapi.controller.test;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+import com.hazelcast.core.IMap;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.utils.error.ValidationException;
+
+@Profile("dev")
+@Controller
+@RequestMapping("/anonymous/reval")
+public class RevalMapController implements InitializingBean {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final ImdgProvider imdgProvider;
+    private IMap<Long, String> revalMap;
+
+    @Autowired
+    public RevalMapController(ImdgProvider imdgProvider) {
+        this.imdgProvider = imdgProvider;
+    }
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        imdgProvider.waitAvailable();
+        this.revalMap = ((HazelcastService) imdgProvider).getHazelcast().getMap("REVAL");
+    }
+
+    private final AtomicLong l = new AtomicLong(
+        1L
+    );
+
+    @ApiOperation(value = "Test backend-api availability.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = String.class)})
+    @RequestMapping(method = RequestMethod.POST, path = "/", produces = MediaType.TEXT_PLAIN_VALUE)
+    @ResponseBody
+    public String processPost(
+        @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+        @RequestBody
+        RevalMapAction revalCommand) throws ClassNotFoundException, ValidationException {
+        log.info("Call test method for backend-api reval maps");
+        List<String> maps = revalCommand.getMaps();
+        if (maps.isEmpty()) {
+            throw new IllegalArgumentException("must be at least one map");
+        }
+        for (String map : maps) {
+            revalMap.put(
+                l.getAndIncrement(),
+                map
+            );
+        }
+        return "success";
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/filter/ClearingCorsFilter.java

@@ -19,18 +19,14 @@ import java.io.IOException;
 public class ClearingCorsFilter extends OncePerRequestFilter {
     private final Logger log = LoggerFactory.getLogger(getClass());
 
-//    private final AConfigurationProperties configuration;
-    //todo cors settings
-    private final String[] meth = new String[] {};//"*"
-    private final String[] orig = new String[] {};//"/**"
+    private final String[] meth = new String[]{};
+    private final String[] orig = new String[]{};
     private final String[] head = new String[] {};
     private final CorsAllowedOriginsService allowedOriginsService;
 
     public ClearingCorsFilter(
-//            AConfigurationProperties configuration,
-            CorsAllowedOriginsService allowedOriginsService
+        CorsAllowedOriginsService allowedOriginsService
     ) {
-//        this.configuration = configuration;
         this.allowedOriginsService = allowedOriginsService;
     }
 
@@ -63,21 +59,7 @@ public class ClearingCorsFilter extends OncePerRequestFilter {
             log.trace("cors filter -> effectiveOrigin={}", effectiveOrigin);
             if (effectiveOrigin != null) {
                 setHeaderValue(httpServletResponse, H_ACCESS_CONTROL_ALLOW_ORIGIN, effectiveOrigin);
-
-//                String methods;
-//                if (meth.length > 0) {
-//                    methods = String.join(", ", meth).toUpperCase(Locale.ROOT);
-//                } else {
-//                    methods = "*";
-//                }
                 setHeaderValue(httpServletResponse, H_ACCESS_CONTROL_ALLOW_METHODS, "*");
-
-//                String headers;
-//                if (head.length > 0) {
-//                    headers = String.join(", ", head).toLowerCase(Locale.ROOT);
-//                } else {
-//                    headers = "*";
-//                }
                 setHeaderValue(httpServletResponse, H_ACCESS_CONTROL_ALLOW_HEADERS, "*");
 
                 setHeaderValue(httpServletResponse, H_ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/filter/CorsAllowedOriginsService.java

@@ -12,7 +12,6 @@ public class CorsAllowedOriginsService {
 
     private final List<Pattern> originPatterns = new ArrayList<>();
 
-    //todo cors settings
     public CorsAllowedOriginsService() {
         for (String originRegex : new String[]{".*"}) {
             originPatterns.add(Pattern.compile(originRegex));

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ActionElement.java

@@ -22,8 +22,6 @@ public class ActionElement {
     @JsonInclude(JsonInclude.Include.NON_EMPTY)
     private Boolean isArray = null;
 
-    //    @JsonProperty(value = "fields", required = true)
-//    private List<Map<String, ActionField>> fields = new LinkedList<>();
     @JsonProperty(value = "fields", required = true)
     private List<ActionField> fields = new LinkedList<>();
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/CudMetaService.java

@@ -10,9 +10,6 @@ import ru.spcex.clearing.platform.messaging.domain.Consts;
 import java.util.HashMap;
 import java.util.Map;
 
-/**
- * todo временная заглушка: нужно добавить парсинг meta.xml и получать инфу оттуда
- */
 @Service
 public class CudMetaService {
     private final Map<String, Class<? extends IAction<?>>> mapping;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/FieldExtracted.java

@@ -58,10 +58,6 @@ public abstract class FieldExtracted {
             if (result == null)
                 break;
         }
-
-        //fixme somehow externalize custom serialization for type
-        // тут нужно вернуть список id объектов а не список самих объектов для случая
-        // - add(r, "addresseeId", o.getAddressee() == null ? null : o.getAddressee().stream().map(ObjectBase::getId).collect(Collectors.toSet()), fieldFilter);
         if (result instanceof Set && ((Set) result).size() > 0) {
             try {
                 Set t = new HashSet();
@@ -70,7 +66,7 @@ public abstract class FieldExtracted {
                     t.add(citem.getMethod(RfHelper.GETTER_NAME_ID).invoke(item));
                 }
                 result = t;
-            } catch (Throwable ignored) {// вернем сами объекты
+            } catch (Throwable ignored) {
             }
         } else if (result instanceof LocalDate) {
             result = result.toString();

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java

@@ -31,13 +31,10 @@ public class GetResponseFactory {
 
     public Collection<Map<String, Object>> responseFromObjectCollection(Collection<?> o) {
         return o.stream()
-                .map(this::responseFromObject)
-                .collect(Collectors.toList());
+            .map(this::responseFromObject)
+            .collect(Collectors.toList());
     }
 
-    /**
-     * dictionaryName - это имя тэга внутри <enum>
-     */
     public Map<String, Object> responseFromDictionary(String dictionaryName, Object o) {
         ObjectExtracted objectExtracted = meta.getEnumsExtractedByTagName().get(dictionaryName);
         if (objectExtracted == null) {
@@ -54,16 +51,10 @@ public class GetResponseFactory {
         return responseFromObjectExtracted(o, objExtr);
     }
 
-    /**
-     * Варианты методов с Class сделаны для сценариев, когда хотим распарсить объект,
-     * по мете для родительского класса объекта
-     * Т.е. вместо извлечение класса o.getClass, берем clazz извне. clazz - base class для o
-     *
-    */
     public <T> Collection<Map<String, Object>> responseFromObjectCollection(Collection<?> o, Class<T> clazz) {
         return o.stream()
-                .map((Function<Object, Map<String, Object>>) o1 -> responseFromObject(o1, clazz))
-                .collect(Collectors.toList());
+            .map((Function<Object, Map<String, Object>>) o1 -> responseFromObject(o1, clazz))
+            .collect(Collectors.toList());
     }
 
     public <T> Map<String, Object> responseFromObject(Object o, Class<T> clazz) {
@@ -83,20 +74,18 @@ public class GetResponseFactory {
                     continue;
                 }
                 currentField = field;
-//                if (fieldsToAdd.contains(field.getField().getCode())) {
-                    try {
-                        add(r, field, field.extractValue(o));
-                    } catch (Throwable e) {
-                        log.trace(ExceptionUtils.getStackTrace(
-                                new RuntimeException(String.format("Can't extract value for field='%s' of %s(%s): %s -> %s\n%s",
-                                        field.getField().getCode(),
-                                        o.getClass().getSimpleName(), objExtr.getClassName(),
-                                        e.getClass().getSimpleName(), e.getLocalizedMessage(),
-                                        currentField.toString()
-                                )))
-                        );
-                    }
-//                }
+                try {
+                    add(r, field, field.extractValue(o));
+                } catch (Throwable e) {
+                    log.trace(ExceptionUtils.getStackTrace(
+                        new RuntimeException(String.format("Can't extract value for field='%s' of %s(%s): %s -> %s\n%s",
+                            field.getField().getCode(),
+                            o.getClass().getSimpleName(), objExtr.getClassName(),
+                            e.getClass().getSimpleName(), e.getLocalizedMessage(),
+                            currentField.toString()
+                        )))
+                    );
+                }
             }
         } catch (Exception e) {
             log.error(ExceptionUtils.getStackTrace(e));
@@ -145,48 +134,7 @@ public class GetResponseFactory {
     }
 
     private static final DateTimeFormatter dateTimeFormatter = DateTimeFormatter
-            .ofPattern("yyyy-MM-dd'T'HH:mm:ss+03:00")
-            .withLocale(Locale.US)
-            .withZone(ZoneId.of("Europe/Moscow"));
-
-
-//    public Map<String, Object> newX(Object o, Collection<String> fieldFilter, String destination) {
-//        ObjectExtracted targetClazz = getTargetClazz(o, destination);
-//        if (targetClazz == null)
-//            throw new FrontendException(String.format("Unknown response class: %s", o.getClass().getName()));
-//        Collection<String> fieldsToAdd = getFilteredFields(targetClazz, fieldFilter);
-//        Map<String, Object> r = new LinkedHashMap<>();
-//        FieldExtracted currentField = null;
-//        try {
-//            for (FieldExtracted field : targetClazz.getFields()) {
-//                if (field.getField().isVirtual() != null && field.getField().isVirtual()) {
-//                    continue;
-//                }
-//                currentField = field;
-//                if (fieldsToAdd.contains(field.getField().getCode())) {
-//                    try {
-//                        add(r, field.getField().getCode(), field.extractValue(o));
-//                    } catch (Throwable e) {
-//                        log.warn(ExceptionUtils.getStackTrace(
-//                                new FrontendException(String.format("Can't extract value for field='%s' of %s(%s): %s -> %s\n%s",
-//                                        field.getField().getCode(),
-//                                        o.getClass().getSimpleName(), targetClazz.getClazz().getSimpleName(),
-//                                        e.getClass().getSimpleName(), e.getLocalizedMessage(),
-//                                        JsonHelper.writeAnyClassToLog(currentField)
-//                                )))
-//                        );
-//                    }
-//                }
-//            }
-//        } catch (FrontendException e) {
-//            throw e;
-//        } catch (Throwable e) {
-//            throw new FrontendException(String.format("Can't get field of %s(%s): %s -> %s\n%s",
-//                    o.getClass().getSimpleName(), targetClazz.getClazz().getSimpleName(),
-//                    e.getClass().getSimpleName(), e.getLocalizedMessage(),
-//                    JsonHelper.writeAnyClassToLog(currentField)
-//            ));
-//        }
-//        return r;
-//    }
+        .ofPattern("yyyy-MM-dd'T'HH:mm:ss+03:00")
+        .withLocale(Locale.US)
+        .withZone(ZoneId.of("Europe/Moscow"));
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java

@@ -39,10 +39,10 @@ public class MetaServer extends MetaBase {
             try {
                 Map<String, ObjectElement> objects = getObjects();
                 log.info("Meta objects:\n{}",
-                        objects.values()
-                                .stream()
-                                .map(ObjectElement::getName)
-                                .collect(Collectors.joining(";", "[", "]")));
+                    objects.values()
+                        .stream()
+                        .map(ObjectElement::getName)
+                        .collect(Collectors.joining(";", "[", "]")));
                 for (String key : objects.keySet()) {
                     ObjectExtracted oe;
                     ObjectElement objectElement = objects.get(key);
@@ -85,8 +85,8 @@ public class MetaServer extends MetaBase {
                             log.warn("META SERVER >>> {}", e.getLocalizedMessage());
                             continue;
                         }
-                        String actionDestination = // обычно бывают =null о этому эффективнее по имени класса а не по: objectElement.getSubscription().destination + "/"+ actionElement.getDestination();
-                                oe.getClassName();
+                        String actionDestination =
+                            oe.getClassName();
                         actionObjectsExtracted.put(actionDestination, oe);
                     }
                 }
@@ -104,20 +104,6 @@ public class MetaServer extends MetaBase {
                         log.warn("{} {}", key, ExceptionUtils.getStackTrace(e));
                         continue;
                     }
-                    /**
-                     * можно было бы хранить только для нестандартных словарей (где не только id, name, code)
-                     */
-//                    List<FieldExtracted> dictFields = oe.getFields();
-//                    boolean add = false;
-//                    for (FieldExtracted dictField : dictFields) {
-//                        if (!dictionaryDefaultFields.contains(dictField.getMemberName())) {
-//                            add = true;
-//                            break;
-//                        }
-//                    }
-//                    if (add) {
-//                        enumsExtractedByTagName.put(key, oe);
-//                    }
                     enumsExtractedByTagName.put(key, oe);
                 }
 
@@ -130,7 +116,6 @@ public class MetaServer extends MetaBase {
                 if (!RfHelper.isAbstract(o.getClazz())) {
                     try {
                         Object instance = newInstance(o.getClassName());
-                        // создается успешно.
                     } catch (Throwable e) {
                         log.warn("META SERVER >>> Не удается создать класс {} !", o.getClassName());
                     }
@@ -142,32 +127,8 @@ public class MetaServer extends MetaBase {
                 throw new ClearingMetaServerValidationException(e.getLocalizedMessage());
             }
         }
-//
-//        for (ObjectExtracted o : this.actionObjectsExtracted.values()) {
-//            try {
-//                if (!RfHelper.isAbstract(o.getClazz())) {
-//                    try {
-//                        Object instance = newInstance(o.getClassName());
-//                        // создается успешно.
-//                    } catch (Throwable e) {
-//                        log.warn("META SERVER ACTION >>> Не удается создать класс {} !", o.getClassName());
-//                    }
-//                }
-//                validateGetterForObject(o);
-//            } catch (ClrxMetaServerGetterNotFoundException e) {
-//                throw e;
-//            } catch (Throwable e) {
-//                throw new ClearingMetaServerValidationException(e.getLocalizedMessage());
-//            }
-//        }
     }
 
-    /**
-     * проверим наличие геттеров к полям
-     *
-     * @param o
-     * @throws ClassNotFoundException
-     */
     private void validateGetterForObject(ObjectExtracted o) throws ClassNotFoundException {
         for (FieldExtracted field : o.getFields()) {
             Class<?> c = o.getClazz();

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/RfHelper.java

@@ -47,7 +47,7 @@ public class RfHelper {
             Class<?> raw = Class.forName(((ParameterizedType) t).getRawType().getTypeName());
             if (BUSINESS_OBJECT_REF.equals(raw.getSimpleName())) {
                 return Class.forName(((ParameterizedType) t).getActualTypeArguments()[0].getTypeName());
-            } else if ("Set".equals(raw.getSimpleName())) { // множества пока не распаковываем
+            } else if ("Set".equals(raw.getSimpleName())) {
                 return Class.forName(raw.getName());
             }
         }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/security/KeycloakRestTemplateAuthenticationProvider.java

@@ -85,7 +85,6 @@ public class KeycloakRestTemplateAuthenticationProvider implements Authenticatio
                 throw new AuthenticationServiceException("keycloak direct access grant auth failed: bad token");
             }
             AccessToken accessToken = AdapterTokenVerifier.verifyToken(accessTokenString, deployment);
-            //todo cors settings
             accessToken.setAllowedOrigins(Collections.singleton("*"));
 
             RefreshableKeycloakSecurityContext skSession = new RefreshableKeycloakSecurityContext(deployment, null, accessTokenString, accessToken, null, null, refreshTokenString);
@@ -93,21 +92,21 @@ public class KeycloakRestTemplateAuthenticationProvider implements Authenticatio
             final KeycloakPrincipal<RefreshableKeycloakSecurityContext> principal = new KeycloakPrincipal<>(principalName, skSession);
             Set<String> roles = AdapterUtils.getRolesFromSecurityContext(skSession);
             Set<String> effectiveRoles = roles
-                    .stream()
-                    .map(s -> {
-                        UserRole userRole = roleMapping.get(s);
-                        return userRole != null ? userRole.getKey() : null;
-                    })
-                    .filter(Objects::nonNull)
-                    .collect(Collectors.toSet());
+                .stream()
+                .map(s -> {
+                    UserRole userRole = roleMapping.get(s);
+                    return userRole != null ? userRole.getKey() : null;
+                })
+                .filter(Objects::nonNull)
+                .collect(Collectors.toSet());
             List<SimpleGrantedAuthority> realmRoles = effectiveRoles.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
             final KeycloakAccount account = new SimpleKeycloakAccount(principal, effectiveRoles, skSession);
             KeycloakAuthenticationToken keycloakAuthenticationToken = new KeycloakAuthenticationToken(account, false, realmRoles);
             keycloakAuthenticationToken.setAuthenticated(true);
             log.debug("login successful: login {}, roles from keycloak: {}; effective roles {}",
-                    authentication.getName(),
-                    String.join(";", roles),
-                    String.join(";", effectiveRoles)
+                authentication.getName(),
+                String.join(";", roles),
+                String.join(";", effectiveRoles)
             );
             return keycloakAuthenticationToken;
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/security/KeycloakUtils.java

@@ -10,20 +10,17 @@ import org.springframework.security.core.Authentication;
 public class KeycloakUtils {
     static Logger log = LoggerFactory.getLogger(KeycloakUtils.class);
 
-    /**
-     * Достать username из Keycloak имплементации Authentication
-     */
     public static String getUserNameFromAuthentication(Authentication authentication) {
         if (authentication == null) return null;
-        if (!(authentication instanceof KeycloakAuthenticationToken)) { // AnonymousAuthenticationToken
+        if (!(authentication instanceof KeycloakAuthenticationToken)) {
             log.trace("Authentication token class {} is not KeycloakAuthenticationToken", authentication.getClass().getName());
             return null;
         }
         KeycloakAuthenticationToken auth = (KeycloakAuthenticationToken) authentication;
         KeycloakAccount details = (KeycloakAccount) auth.getDetails();
         return ((KeycloakPrincipal) details.getPrincipal())
-                .getKeycloakSecurityContext()
-                .getToken()
-                .getPreferredUsername();
+            .getKeycloakSecurityContext()
+            .getToken()
+            .getPreferredUsername();
     }
 }