DM_X search: statuses PROC/MNG

optional max-poll-interval-ms setting

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

@@ -0,0 +1,101 @@
+package ru.spcex.clearing.account.config.validation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.AccountSymbols;
+import ru.spcex.clearing.account.errors.AccountError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.AccountSymbolsNewRequest;
+import ru.spcex.clearing.validation.common.rules.FieldNotBlankRequiredRule;
+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.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;
+import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Configuration
+public class AccountSymbolsValidationConfig {
+
+    @Bean("accountSymbolsDepoNewRequest")
+    public Function<AccountSymbolsNewRequest, IValidator> accountSymbolsDepoNewRequestValidator(
+            Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
+    ) {
+        return accountSymbolsNewRequest -> {
+            ImdgValidationContext<AccountSymbolsNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(accountSymbolsNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_AccountSymbols);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("accountId",
+                            AccountSymbolsNewRequest::getAccountId,
+                            IMDGDistributedNames.Map_Account,
+                            Account.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.AccountNotFound,
+                            true,
+                            (Account account) -> {
+                                if (AccountType.Depo.equalsByKey(account.getAccountType())) {
+                                    return null;
+                                } else {
+                                    return AccountError.AccountDepoTypeRequired;
+                                }
+                            }
+                    ),
+                    FieldNotBlankRequiredRule.instance("accountSymbolValue",
+                            AccountSymbolsNewRequest::getAccountSymbolValue,
+                            AccountError.RequiredFieldEmpty, true),
+                    new DuplicateAccountSymbolsRule()
+            );
+        };
+    }
+
+    static class DuplicateAccountSymbolsRule implements IValidationRule<ImdgValidationContext<AccountSymbolsNewRequest>> {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<AccountSymbolsNewRequest> context) {
+            AccountSymbolsNewRequest validatedObject = context.getValidatedObject();
+            Imdg<AccountSymbols> accountSymbolsImdg = context.obtainMap(IMDGDistributedNames.Map_AccountSymbols, AccountSymbols.class);
+
+            ImdgPredicateBuilder pb = accountSymbolsImdg.predicateBuilder();
+            ImdgPredicate query = pb.or(
+                    pb.equals("accountId", validatedObject.getAccountId()),
+                    pb.equals("accountSymbolValue", validatedObject.getAccountSymbolValue())
+            );
+            Collection<AccountSymbols> existAccSymbols = accountSymbolsImdg.getCollectionObjectsByPredicate(query);
+
+            if (existAccSymbols.isEmpty()) {
+                return empty();
+            } else {
+                AccountSymbols existAS = existAccSymbols.iterator().next();
+                String duplicateMsg = "";
+                if (validatedObject.getAccountId() != null && validatedObject.getAccountId().equals(existAS.getAccountId())) {
+                    Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+                    Account linkedAccount = accountImdg.getSingleObjectByID(existAS.getAccountId());
+                    if (linkedAccount != null) {
+                        duplicateMsg = linkedAccount.getAccount();
+                    } else {
+                        duplicateMsg = "" + existAS.getAccountId();
+                    }
+                }
+                if (validatedObject.getAccountSymbolValue() != null &&
+                        validatedObject.getAccountSymbolValue().equals(existAS.getAccountSymbolValue())) {
+                    if (!duplicateMsg.isEmpty())
+                        duplicateMsg += ", ";
+                    duplicateMsg += existAS.getAccountSymbolValue();
+                }
+                return of(AccountError.AccountAlreadyExist, duplicateMsg);
+            }
+        }
+    }
+}

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

@@ -12,16 +12,18 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAcco
 import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountUpdateRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest;
 import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
-import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
 import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.clearing.validation.common.rules.specific.FieldRequiredSpecificRule;
+import ru.spcex.clearing.validation.common.rules.specific.IdPresentSpecificRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.AccountStatus;
 import ru.spcex.platform.enumeration.AccountType;
-import ru.spcex.platform.enumeration.ServiceStatus;
 import ru.spcex.platform.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.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
 
@@ -53,11 +55,18 @@ public class AccountValidationConfig {
                             Company.class,
                             AccountError.RequiredFieldEmpty,
                             AccountError.CompanyNotFound
+//                            company -> WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? null : AccountError.CompanyNotActive
                     ),
-                    FieldRequiredRule.instance("account",
+                    FieldRequiredSpecificRule.instance("account",
                             CorrespondentAccountNewRequest::getAccount,
-                            AccountError.RequiredFieldEmpty,
+                            AccountError.AccountFieldNotSet,
+                            false,
                             accountValue -> {
+                                if ((accountValue == null || accountValue.isBlank()) && AccountType.Info.equalsByKey(context.getValidatedObject().getAccountType())) {
+                                    return null;
+                                }
+                                if (accountValue == null || accountValue.isBlank())
+                                    return new EnumMessage(AccountError.AccountFieldNotSet, "account");
                                 Imdg<Account> accountImdg = context.obtainMap(
                                         IMDGDistributedNames.Map_Account, Account.class
                                 );
@@ -67,29 +76,37 @@ public class AccountValidationConfig {
                                 ImdgPredicate finalPredicate = pb.and(accountValuePredicate, accountStatusPredicate);
                                 Collection<Account> accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate);
                                 if (accounts.isEmpty()) return null;
-                                return AccountError.AccountAlreadyExist;
+                                return new EnumMessage(AccountError.AccountAlreadyExist, accounts.stream().findFirst().get().getAccount());
                             }),
                     DictionaryPresentRule.instance("status",
                             CorrespondentAccountNewRequest::getStatus,
                             IMDGDistributedNames.Map_ServiceStatusDictionary,
                             ServiceStatusDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
-                            false,
-                            statusValue -> {
-                                if (ServiceStatus.Active.equalsByKey(statusValue.getCode())) return null;
-                                return AccountError.WrongFieldValue;
-                            }),
+                            AccountError.DictionaryNotFound,
+                            false
+//                           , statusValue -> {
+//                                if (ServiceStatus.Active.equalsByKey(statusValue.getCode())) return null;
+//                                return AccountError.WrongFieldValue;
+//                            }
+                    ),
                     DictionaryPresentRule.instance("accountType",
                             CorrespondentAccountNewRequest::getAccountType,
                             IMDGDistributedNames.Map_AccountTypeDictionary,
                             AccountTypeDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
+                            AccountError.DictionaryNotFound,
                             accountType -> {
-                                if (AccountType.Corr.equalsByKey(accountType.getCode())) return null;
+                                if (IEnumKey.contains(accountType.getCode(), AccountType.Corr, AccountType.Info)) return null;
                                 return AccountError.WrongFieldValue;
-                            })
+                            }).withMessageDecorator((causeEmpty, errorCode, fieldName, fieldValue) -> {
+                                if (errorCode == AccountError.WrongFieldValue)
+                                    return DictionaryPresentRule.FIELD_NOT_FOUND_DECORATOR_1.decorator(causeEmpty, errorCode, fieldName, fieldValue);
+                                else
+                                    return DictionaryPresentRule.DICTIONARY_NOT_FOUND_DECORATOR_2.decorator(causeEmpty, errorCode, fieldName, fieldValue);
+                            }
+                            ),
+                    new SameAccountValidationRule<>(AccountType.Corr, CorrespondentAccountNewRequest::getAccount)
             );
         };
     }
@@ -130,18 +147,20 @@ public class AccountValidationConfig {
                             IMDGDistributedNames.Map_ServiceStatusDictionary,
                             ServiceStatusDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
+                            AccountError.DictionaryNotFound,
                             false),
                     DictionaryPresentRule.instance("accountType",
                             CorrespondentAccountUpdateRequest::getAccountType,
                             IMDGDistributedNames.Map_AccountTypeDictionary,
                             AccountTypeDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
-                            accountType -> {
-                                if (AccountType.Corr.equalsByKey(accountType.getCode())) return null;
-                                return AccountError.WrongFieldValue;
-                            })
+                            AccountError.DictionaryNotFound,
+                            false
+//                            accountType -> {
+//                                if (AccountType.Corr.equalsByKey(accountType.getCode())) return null;
+//                                return AccountError.WrongFieldValue;
+//                            }
+                    )
             );
         };
     }
@@ -156,14 +175,15 @@ public class AccountValidationConfig {
             Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
             addImdg.accept(IMDGDistributedNames.Map_Account);
             return new ValidatorImpl<>(context,
-                    IdPresentRule.instance("id",
+                    IdPresentSpecificRule.instance("id",
                             CommonIdRequest::getId,
                             IMDGDistributedNames.Map_Account,
                             Account.class,
                             AccountError.RequiredFieldEmpty,
                             AccountError.AccountNotFound,
                             account -> {
-                                if (AccountStatus.BLOCKED.equalsByKey(account.getStatus())) return AccountError.AccountNotActive;
+                                if (AccountStatus.BLOCKED.equalsByKey(account.getStatus()))
+                                    return new EnumMessage(AccountError.AccountNotActive, account.getAccount());
                                 return null;
                             })
             );

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

@@ -13,16 +13,17 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewReq
 import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountUpdateRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest;
 import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
+import ru.spcex.clearing.validation.common.rules.FieldNotBlankRequiredRule;
 import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
 import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.clearing.validation.common.rules.specific.FieldRequiredSpecificRule;
+import ru.spcex.clearing.validation.common.rules.specific.IdPresentSpecificRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.AccountStatus;
 import ru.spcex.platform.enumeration.AccountType;
-import ru.spcex.platform.enumeration.ServiceStatus;
 import ru.spcex.platform.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.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
 
@@ -55,30 +56,17 @@ public class BankAccountValidationConfig {
                             AccountError.RequiredFieldEmpty,
                             AccountError.CompanyNotFound,
                             false),
-                    FieldRequiredRule.instance("account",
+                    FieldNotBlankRequiredRule.instance("account",
                             BankAccountNewRequest::getAccount,
-                            AccountError.RequiredFieldEmpty,
-                            accountValue -> {
-                                Imdg<Account> accountImdg = context.obtainMap(
-                                        IMDGDistributedNames.Map_Account, Account.class
-                                );
-                                ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
-                                ImdgPredicate accountValuePredicate = pb.equals("account", accountValue);
-                                ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey());
-                                ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Bank.getKey());
-                                ImdgPredicate finalPredicate = pb.and(accountValuePredicate,
-                                        accountStatusPredicate,
-                                        accountTypePredicate);
-                                Collection<Account> accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate);
-                                if (accounts.isEmpty()) return null;
-                                return AccountError.AccountAlreadyExist;
-                            }),
+                            AccountError.RequiredFieldEmpty
+                    ),
+                    new SameAccountValidationRule<>(AccountType.Bank, BankAccountNewRequest::getAccount),
                     DictionaryPresentRule.instance("currency",
                             BankAccountNewRequest::getCurrency,
                             IMDGDistributedNames.Map_CurrencyCodeDictionary,
                             CurrencyCodeDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue),
+                            AccountError.DictionaryNotFound),
                     FieldRequiredRule.instance("bankIdentificationCode",
                             BankAccountNewRequest::getBankIdentificationCode,
                             AccountError.RequiredFieldEmpty),
@@ -90,7 +78,7 @@ public class BankAccountValidationConfig {
                             IMDGDistributedNames.Map_ServiceStatusDictionary,
                             ServiceStatusDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
+                            AccountError.DictionaryNotFound,
                             false)
             );
         };
@@ -122,6 +110,7 @@ public class BankAccountValidationConfig {
                                 );
                                 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",
@@ -129,7 +118,7 @@ public class BankAccountValidationConfig {
                             IMDGDistributedNames.Map_CurrencyCodeDictionary,
                             CurrencyCodeDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
+                            AccountError.DictionaryNotFound,
                             false)
             );
         };
@@ -146,7 +135,7 @@ public class BankAccountValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_BankAccount);
             addImdg.accept(IMDGDistributedNames.Map_Account);
             return new ValidatorImpl<>(context,
-                    IdPresentRule.instance("id",
+                    IdPresentSpecificRule.instance("id",
                             CommonIdRequest::getId,
                             IMDGDistributedNames.Map_BankAccount,
                             BankAccount.class,
@@ -158,8 +147,10 @@ public class BankAccountValidationConfig {
                                         IMDGDistributedNames.Map_Account, Account.class
                                 );
                                 Account account = accountImdg.getSingleObjectByID(accountId);
-                                if (account == null) return AccountError.AccountNotFound;
-                                if (AccountStatus.BLOCKED.equalsByKey(account.getStatus())) return AccountError.AccountNotActive;
+                                if (account == null)
+                                    return new EnumMessage(AccountError.AccountNotFound, accountId);
+                                if (AccountStatus.BLOCKED.equalsByKey(account.getStatus()))
+                                    return new EnumMessage(AccountError.AccountNotActive, account.getAccount());
                                 return null;
                             })
             );

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

@@ -11,8 +11,10 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.ClearingAccountNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.ClearingAccountUpdateRequest;
 import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
+import ru.spcex.clearing.validation.common.rules.FieldNotBlankRequiredRule;
 import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
 import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.clearing.validation.common.rules.specific.FieldRequiredSpecificRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.AccountType;
 import ru.spcex.platform.enumeration.ServiceStatus;
@@ -51,37 +53,24 @@ public class ClearingAccountValidationConfig {
                             Company.class,
                             AccountError.RequiredFieldEmpty,
                             AccountError.CompanyNotFound
+//                            company -> !WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? AccountError.CompanyNotActive : null
                     ),
-                    FieldRequiredRule.instance("account",
+                    FieldNotBlankRequiredRule.instance("account",
                             ClearingAccountNewRequest::getAccount,
-                            AccountError.RequiredFieldEmpty,
-                            accountValue -> {
-                                Imdg<Account> accountImdg = context.obtainMap(
-                                        IMDGDistributedNames.Map_Account, Account.class
-                                );
-                                ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
-                                ImdgPredicate accountValuePredicate = pb.equals("account", accountValue);
-                                ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey());
-                                ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey());
-                                ImdgPredicate finalPredicate = pb.and(accountValuePredicate,
-                                        accountStatusPredicate,
-                                        accountTypePredicate);
-                                Collection<Account> accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate);
-                                if (accounts.isEmpty()) return null;
-                                return AccountError.AccountAlreadyExist;
-                            }),
+                            AccountError.RequiredFieldEmpty),
+                    new SameAccountValidationRule<>(AccountType.Clrn, ClearingAccountNewRequest::getAccount),
                     DictionaryPresentRule.instance("clearingAccountType",
                             ClearingAccountNewRequest::getClearingAccountType,
                             IMDGDistributedNames.Map_ClearingAccountTypeDictionary,
                             ClearingAccountTypeDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue),
+                            AccountError.DictionaryNotFound),
                     DictionaryPresentRule.instance("status",
                             ClearingAccountNewRequest::getStatus,
                             IMDGDistributedNames.Map_ServiceStatusDictionary,
                             ServiceStatusDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
+                            AccountError.DictionaryNotFound,
                             false)
             );
         };
@@ -105,6 +94,8 @@ public class ClearingAccountValidationConfig {
                             ClearingAccountUpdateRequest::getAccount,
                             AccountError.RequiredFieldEmpty,
                             accountValue -> {
+                                if (accountValue.isBlank())
+                                    return AccountError.RequiredFieldEmpty;
                                 Imdg<Account> accountImdg = context.obtainMap(
                                         IMDGDistributedNames.Map_Account, Account.class
                                 );

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

@@ -148,6 +148,7 @@ 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,

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

@@ -9,14 +9,13 @@ import ru.spcex.clearing.account.errors.AccountError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.DepoAccountNewRequest;
 import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
+import ru.spcex.clearing.validation.common.rules.FieldNotBlankRequiredRule;
 import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
 import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.clearing.validation.common.rules.specific.FieldRequiredSpecificRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.AccountType;
-import ru.spcex.platform.enumeration.ServiceStatus;
 import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
-import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.utils.validation.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
@@ -48,25 +47,12 @@ public class DepoAccountValidationConfig {
                             Company.class,
                             AccountError.RequiredFieldEmpty,
                             AccountError.CompanyNotFound
+//                            company -> !WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? AccountError.CompanyNotActive : null
                     ),
-                    FieldRequiredRule.instance("account",
+                    FieldNotBlankRequiredRule.instance("account",
                             DepoAccountNewRequest::getAccount,
-                            AccountError.RequiredFieldEmpty,
-                            accountValue -> {
-                                Imdg<Account> accountImdg = context.obtainMap(
-                                        IMDGDistributedNames.Map_Account, Account.class
-                                );
-                                ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
-                                ImdgPredicate accountValuePredicate = pb.equals("account", accountValue);
-                                ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey());
-                                ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey());
-                                ImdgPredicate finalPredicate = pb.and(accountValuePredicate,
-                                        accountStatusPredicate,
-                                        accountTypePredicate);
-                                Collection<Account> accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate);
-                                if (accounts.isEmpty()) return null;
-                                return AccountError.AccountAlreadyExist;
-                            }),
+                            AccountError.RequiredFieldEmpty),
+                    new SameAccountValidationRule<>(AccountType.Depo, DepoAccountNewRequest::getAccount),
                     FieldRequiredRule.instance("depoAccountType",
                             DepoAccountNewRequest::getDepoAccountType,
                             AccountError.RequiredFieldEmpty),
@@ -75,7 +61,7 @@ public class DepoAccountValidationConfig {
                             IMDGDistributedNames.Map_ServiceStatusDictionary,
                             ServiceStatusDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
+                            AccountError.DictionaryNotFound,
                             false)
             );
         };

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

@@ -2,20 +2,23 @@ package ru.spcex.clearing.account.config.validation;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import ru.clearing.classes.statics.data.account.InformationAccount;
 import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.platform.dictionary.AccountTypeDictionary;
+import ru.clearing.platform.dictionary.ServiceStatusDictionary;
 import ru.spcex.clearing.account.errors.AccountError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.InformationAccountNewRequest;
+import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
+import ru.spcex.clearing.validation.common.rules.FieldNotBlankRequiredRule;
 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.WorkflowStatus;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.utils.validation.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
 
-import java.util.Collection;
 import java.util.Map;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -33,6 +36,9 @@ public class InformationAccountValidationConfig {
             Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
             addImdg.accept(IMDGDistributedNames.Map_Company);
             addImdg.accept(IMDGDistributedNames.Map_InformationAccount);
+            addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_AccountTypeDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_Account);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("companyId",
                             InformationAccountNewRequest::getCompanyId,
@@ -43,16 +49,17 @@ public class InformationAccountValidationConfig {
                             company -> {
                                 if (!WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()))
                                     return AccountError.CompanyNotActive;
-                                Long companyId = company.getId();
-                                Imdg<InformationAccount> informationAccountImdg = context.obtainMap(
-                                        IMDGDistributedNames.Map_InformationAccount, InformationAccount.class
-                                );
-                                Collection<InformationAccount> infoAccounts = informationAccountImdg.getCollectionObjectsByFieldValues(
-                                        Map.of("companyId", companyId)
-                                );
-                                if (infoAccounts.isEmpty()) return null;
-                                return AccountError.InfoAccountAlreadyExist;
-                            })
+                                return null;
+                            }),
+                    FieldNotBlankRequiredRule.instance("account", InformationAccountNewRequest::getAccount,
+                            AccountError.RequiredFieldEmpty),
+                    DictionaryPresentRule.instance("status", InformationAccountNewRequest::getStatus,
+                            IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class,
+                            AccountError.RequiredFieldEmpty, AccountError.DictionaryNotFound, false),
+                    DictionaryPresentRule.instance("accountType", InformationAccountNewRequest::getAccountType,
+                            IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.class,
+                            AccountError.RequiredFieldEmpty, AccountError.DictionaryNotFound, false),
+                    new SameAccountValidationRule<>(AccountType.Info, InformationAccountNewRequest::getAccount)
             );
         };
     }

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

@@ -0,0 +1,46 @@
+package ru.spcex.clearing.account.config.validation;
+
+import ru.clearing.classes.statics.data.account.Account;
+import ru.spcex.clearing.account.errors.AccountError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.ServiceStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.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;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+
+class SameAccountValidationRule<R> implements IValidationRule<ImdgValidationContext<R>> {
+    final String accountType;
+    final Function<R, String> accountGetter;
+
+    public SameAccountValidationRule(AccountType accountType, Function<R, String> accountGetter) {
+        this.accountType = accountType.getKey(); // or req.getAccountType()
+        this.accountGetter = accountGetter;
+        Objects.requireNonNull(accountGetter);
+    }
+
+    @Override
+    public Optional<EnumMessage> validate(ImdgValidationContext<R> context) {
+        R req = context.getValidatedObject();
+        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())
+        );
+        Account existAccount = accountImdg.getFirstObjectByPredicate(query);
+        if (existAccount != null) {
+            return of(AccountError.AccountAlreadyExist, existAccount.getAccount());
+        }
+        return empty();
+    }
+
+}

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

@@ -16,6 +16,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingR
 import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
 import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
 import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.clearing.validation.common.rules.specific.IdPresentSpecificRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.AccountType;
 import ru.spcex.platform.enumeration.CompanySymbol;
@@ -33,7 +34,6 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 
 @Configuration
 public class TradingClearingRegistryValidationConfig {
@@ -55,7 +55,7 @@ public class TradingClearingRegistryValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_ServiceStatusDictionary);
             addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
             return new ValidatorImpl<>(context,
-                    IdPresentRule.instance("companyId",
+                    IdPresentSpecificRule.instance("companyId",
                             TradingClearingRegistryNewRequest::getCompanyId,
                             IMDGDistributedNames.Map_Company,
                             Company.class,
@@ -68,7 +68,8 @@ public class TradingClearingRegistryValidationConfig {
                                         "companyId", company.getId(),
                                         "companySymbol", CompanySymbol.CLRC.getKey()
                                 ));
-                                if (symbol == null) return AccountError.ClearingCompanySymbolNotFound;
+                                if (symbol == null)
+                                    return new EnumMessage(AccountError.ClearingCompanySymbolNotFound, company.getShortName());
                                 return null;
                             }),
                     FieldRequiredRule.instance("moneyAccountId",
@@ -83,10 +84,26 @@ public class TradingClearingRegistryValidationConfig {
                                     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",
@@ -107,7 +124,7 @@ public class TradingClearingRegistryValidationConfig {
                             IMDGDistributedNames.Map_ServiceStatusDictionary,
                             ServiceStatusDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
+                            AccountError.DictionaryNotFound,
                             false),
                     new newTCRDuplicateCheck()
             );
@@ -123,6 +140,11 @@ 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) {
@@ -134,8 +156,12 @@ public class TradingClearingRegistryValidationConfig {
             if (existTCR.isEmpty()) {
                 return empty();
             } else {
-                String tcrIds = existTCR.stream().map(tcr -> String.valueOf(tcr.getId())).collect(Collectors.joining(";"));
-                return of(AccountError.AccountForTradingClearingRegistryAlreadyUsed, tcrIds);
+                Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+                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);
             }
         }
     }
@@ -163,7 +189,7 @@ public class TradingClearingRegistryValidationConfig {
                             IMDGDistributedNames.Map_ServiceStatusDictionary,
                             ServiceStatusDictionary.class,
                             AccountError.RequiredFieldEmpty,
-                            AccountError.WrongFieldValue,
+                            AccountError.DictionaryNotFound,
                             false)
             );
         };

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

@@ -8,10 +8,7 @@ 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.registry.TradingClearingRegistry;
-import ru.clearing.platform.dictionary.AccountTypeDictionary;
-import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary;
-import ru.clearing.platform.dictionary.CurrencyCodeDictionary;
-import ru.clearing.platform.dictionary.ServiceStatusDictionary;
+import ru.clearing.platform.dictionary.*;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.validation.common.ValidationHelper;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
@@ -44,6 +41,9 @@ public class ValidationConfig {
         addImdg.accept(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
         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_ClientCode, ClientCode.class);
 
         return imdg;

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

@@ -19,8 +19,10 @@ public enum AccountError implements IErrorEnumId {
     DepoAccountNotFound(5017L),
     MoneyAccountNotFound(5018L),
     ClearingCategoryNotFound(5019L),
-    ClearingCompanySymbolNotFound(5022L),
+    ClearingCompanySymbolNotFound(5022L), // Для компании %s отсутствует клиринговый код».
     AccountForTradingClearingRegistryAlreadyUsed(5023L),
+    AccountFieldNotSet(5024L),
+    AccountDepoTypeRequired(5025L),
     TradingClearingRegistryNotFound(3022L),
     ;
 

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

@@ -0,0 +1,106 @@
+package ru.spcex.clearing.account.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+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.company.ClearingMemberCategory;
+import ru.clearing.classes.statics.data.company.relation.Relation;
+import ru.spcex.clearing.account.errors.AccountError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.platform.messaging.service.Status;
+import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IEnumKey;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+
+import java.util.Collection;
+
+@Service
+public class AccountHelper {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final Imdg<ClearingMemberCategory> clearingMemberCategoryMap;
+    private final Imdg<Relation> relationMap;
+    private final IMessageResolver messageResolver;
+
+    @Autowired
+    public AccountHelper(ImdgProvider imdgProvider,
+                         IMessageResolver messageResolver) {
+        this.clearingMemberCategoryMap = imdgProvider.getImdg(
+                IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class
+        );
+        this.relationMap = imdgProvider.getImdg(
+                IMDGDistributedNames.Map_Relation, Relation.class
+        );
+        this.messageResolver = messageResolver;
+    }
+
+    /**
+     * Заполняет поля relationId и companyId из соответствующей записи Relation
+     *
+     * @param requestId Идентификатор запроса для вывода лога
+     */
+    public RequestInfoUpdate fillAccountFromRelation(Account account, Long requestId, boolean checkClearingMemberCategory) {
+        Long companyId = account.getCompanyId();
+        Collection<Relation> relations;
+        ImdgPredicateBuilder relationPredicateBuilder = relationMap.predicateBuilder();
+        ImdgPredicate finalRelationPredicate;
+        if (checkClearingMemberCategory) {
+            ImdgPredicateBuilder clearingMemberCategoryPredicateBuilder = clearingMemberCategoryMap.predicateBuilder();
+            ImdgPredicate companyIdEquals = clearingMemberCategoryPredicateBuilder.equals("companyId", companyId);
+            Collection<ClearingMemberCategory> clearingMemberCategories = clearingMemberCategoryMap.getCollectionObjectsByPredicate(companyIdEquals);
+
+            if (clearingMemberCategories.isEmpty())
+                return makeError(requestId, AccountError.ClearingCategoryNotFound, companyId, "(any)");
+            if (clearingMemberCategories.size() > 1)
+                log.warn("ClearingMemberCategory for companyId {} contains multiply elements, use first", companyId);
+            ClearingMemberCategory clearingMemberCategory = clearingMemberCategories.iterator().next();
+
+            ImdgPredicate consumerIdPredicate = relationPredicateBuilder.equals("consumerId", companyId);
+            ImdgPredicate servicePredicate;
+            String clearingCategoryValue = clearingMemberCategory.getClearingMemberCategory();
+            if (IEnumKey.contains(clearingCategoryValue, ClearingCategory.B, ClearingCategory.I, ClearingCategory.V)) {
+                servicePredicate = relationPredicateBuilder.equals("service", ru.spcex.platform.enumeration.Service.MKR.getKey());
+            } else if (IEnumKey.contains(clearingCategoryValue, ClearingCategory.F, ClearingCategory.C)) {
+                servicePredicate = relationPredicateBuilder.equals("service", ru.spcex.platform.enumeration.Service.FOND.getKey());
+            } 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);
+        } else {
+            finalRelationPredicate = relationPredicateBuilder.equals("consumerId", companyId);
+            relations = relationMap.getCollectionObjectsByPredicate(finalRelationPredicate);
+        }
+
+        if (relations.isEmpty()) {
+            //return makeError(requestId, AccountError.WrongFieldValue, "companyId", finalRelationPredicate.toString());
+            log.info("Relation not found: {}", finalRelationPredicate.toString());
+            return null;
+        }
+        if (relations.size() > 1)
+            log.warn("Relation for consumerId {} contains multiply elements, use first", companyId);
+        Relation relation = relations.iterator().next();
+        account.setRelationId(relation.getId());
+
+        return null;
+    }
+
+    public 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);
+    }
+
+}

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

@@ -9,6 +9,9 @@ import org.springframework.beans.factory.annotation.Autowired;
 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.ClearingMemberCategory;
 import ru.clearing.classes.statics.data.company.relation.Relation;
 import ru.spcex.clearing.account.errors.AccountError;
@@ -25,9 +28,7 @@ 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.ClearingCategory;
-import ru.spcex.platform.enumeration.ServiceStatus;
-import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.ImdgTransaction;
@@ -40,6 +41,7 @@ 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
@@ -53,6 +55,8 @@ public class AccountService extends QueueConsumer implements InitializingBean {
     private final IMessageResolver messageResolver;
     private final UserRoleVerification userRoleVerification;
     private final ValidationHelper validationHelper;
+    private final AccountHelper accountHelper;
+    private final InformationAccountService informationAccountService;
     private final Function<CorrespondentAccountNewRequest, IValidator> accountNewRequestValidator;
     private final Function<CorrespondentAccountUpdateRequest, IValidator> accountUpdateRequestValidator;
     private final Function<CommonIdRequest, IValidator> accountBlockRequestValidator;
@@ -65,6 +69,8 @@ public class AccountService extends QueueConsumer implements InitializingBean {
                           IMessageResolver messageResolver,
                           UserRoleVerification userRoleVerification,
                           ValidationHelper validationHelper,
+                          AccountHelper accountHelper,
+                          InformationAccountService informationAccountService,
                           @Qualifier("correspondentAccountNewRequestValidator")
                                   Function<CorrespondentAccountNewRequest, IValidator> accountNewRequestValidator,
                           @Qualifier("correspondentAccountUpdateRequestValidator")
@@ -72,6 +78,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
                           @Qualifier("correspondentAccountBlockRequestValidator")
                                   Function<CommonIdRequest, IValidator> accountBlockRequestValidator) {
         super(kafkaQueue, kafkaProducer);
+        this.accountHelper = accountHelper;
         this.imdgProvider = imdgProvider;
         this.accountMap = imdgProvider.getImdg(
                 IMDGDistributedNames.Map_Account, Account.class
@@ -86,6 +93,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         this.messageResolver = messageResolver;
         this.userRoleVerification = userRoleVerification;
         this.validationHelper = validationHelper;
+        this.informationAccountService = informationAccountService;
         this.accountNewRequestValidator = accountNewRequestValidator;
         this.accountUpdateRequestValidator = accountUpdateRequestValidator;
         this.accountBlockRequestValidator = accountBlockRequestValidator;
@@ -126,6 +134,12 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         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);
+            log.trace("New info-account SequenceId={} account={}", infoSequenceId, accountValue);
+            account.setAccount(accountValue);
+        }
         account.setAccountType(req.getAccountType());
         if (req.getStatus() == null) {
             account.setStatus(WorkflowStatus.Active.getKey());
@@ -136,14 +150,89 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         account.setCreated(now);
         account.setUpdated(now);
 
-        requestInfoUpdate = fillAccountFromRelation(account, userRequest.getId(), false);
+        requestInfoUpdate = accountHelper.fillAccountFromRelation(account, userRequest.getId(), false);
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
-        Long newId = accountMap.insert(account);
+        Long newId = null;
+        if (AccountType.Corr.equalsByKey(account.getAccountType())) {
+            // default, дополнительные таблицы не требуются
+            newId = accountMap.insert(account);
+        } else {
+            // Транзакцией
+            ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
+            imdgTransaction.beginTransaction();
+            boolean txOk = false;
+            try {
+                Imdg<Account> accountMap = imdgTransaction.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+                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()))
+                    makeDepoPart(imdgTransaction, account, req);
+                else if (AccountType.Clrn.equalsByKey(account.getAccountType()))
+                    makeClrnPart(imdgTransaction, account);
+                else {
+                    log.warn("Unexpected AccountType={}. Do not create additional record to other table's", account.getAccountType());
+                }
+                txOk = true;
+            } finally {
+                if (txOk) {
+                    imdgTransaction.commitTransaction();
+                } else {
+                    log.debug("failed insert, new account id {} rollback", newId);
+                    imdgTransaction.rollbackTransaction();
+                }
+            }
+        }
+
         log.debug("successfully processed, new account id {}", newId);
         return null;
     }
 
+    protected void makeInfoPart(ImdgTransaction imdgTransaction, Account account) {
+        Imdg<InformationAccount> informationAccountMap = imdgTransaction.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class);
+        InformationAccount infoAcc = new InformationAccount();
+        infoAcc.setAccountId(account.getId());
+        Account firstAccountAntl = accountMap.getFirstObjectByFieldValues(Map.of(
+                "companyId", Sender.One.getId(),
+                "accountType", AccountType.Anlt.getKey()
+        ));
+        if (firstAccountAntl == null) {
+            log.warn("Can not find 1 ANTL account for fill information ClearingAccountId.");
+        } else {
+            infoAcc.setClearingAccountId(firstAccountAntl.getId());
+        }
+        infoAcc.setCompanyId(account.getCompanyId());
+        Long infoId = informationAccountMap.insert(infoAcc);
+        log.debug("For account id={} make InformationAccount id={}", account.getId(), infoId);
+    }
+
+    protected void makeDepoPart(ImdgTransaction imdgTransaction, Account account, CorrespondentAccountNewRequest req) {
+        Imdg<DepoAccount> depoAccountMap = imdgTransaction.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
+        DepoAccount depoAcc = new DepoAccount();
+        depoAcc.setAccountId(account.getId());
+        depoAcc.setCompanyId(account.getCompanyId());
+        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);
+    }
+
+    protected void makeClrnPart(ImdgTransaction imdgTransaction, Account account) {
+        Imdg<ClearingAccount> clearingAccountMap = imdgTransaction.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
+        ClearingAccount clnrAcc = new ClearingAccount();
+        clnrAcc.setAccountId(account.getId());
+        clnrAcc.setCompanyId(account.getCompanyId());
+        Long clrnId = clearingAccountMap.insert(clnrAcc);
+        log.debug("For account id={} make ClearingAccount id={}", account.getId(), clrnId);
+    }
+
     public RequestInfoUpdate correspondentAccountUpdate(BaseRequest<CorrespondentAccountUpdateRequest> userRequest) {
         log.debug("CorrespondentAccountUpdateRequest received");
 
@@ -156,6 +245,10 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         CorrespondentAccountUpdateRequest request = userRequest.getRequestPayload();
 
         Account account = accountMap.getSingleObjectByID(request.getId());
+        if (request.getAccountType() != null && !request.getAccountType().equals(account.getAccountType())) {
+            requestInfoUpdate = makeError(userRequest.getId(), AccountError.WrongFieldValue, "accountType");
+            return requestInfoUpdate;
+        }
 
         if (request.getStatus() != null) account.setStatus(request.getStatus());
 
@@ -193,7 +286,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;
+        if (requestInfoUpdate != null) return requestInfoUpdate; // never - system
 
         AccountTerminationRequest req = userRequest.getRequestPayload();
         final Long companyId = req.getCompanyId();
@@ -205,6 +298,7 @@ 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());
@@ -229,53 +323,6 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         return null;
     }
 
-
-    public RequestInfoUpdate fillAccountFromRelation(Account account, Long requestId, boolean checkClearingMemberCategory) {
-        Long companyId = account.getCompanyId();
-        Collection<Relation> relations;
-        ImdgPredicateBuilder relationPredicateBuilder = relationMap.predicateBuilder();
-        ImdgPredicate finalRelationPredicate;
-        if (checkClearingMemberCategory) {
-            ImdgPredicateBuilder clearingMemberCategoryPredicateBuilder = clearingMemberCategoryMap.predicateBuilder();
-            ImdgPredicate companyIdEquals = clearingMemberCategoryPredicateBuilder.equals("companyId", companyId);
-            Collection<ClearingMemberCategory> clearingMemberCategories = clearingMemberCategoryMap.getCollectionObjectsByPredicate(companyIdEquals);
-
-            if (clearingMemberCategories.isEmpty())
-                return makeError(requestId, AccountError.ClearingCategoryNotFound, companyId, "(any)");
-            if (clearingMemberCategories.size() > 1)
-                log.warn("ClearingMemberCategory for companyId {} contains multiply elements, use first", companyId);
-            ClearingMemberCategory clearingMemberCategory = clearingMemberCategories.iterator().next();
-
-            ImdgPredicate consumerIdPredicate = relationPredicateBuilder.equals("consumerId", companyId);
-            ImdgPredicate servicePredicate;
-            String clearingCategoryValue = clearingMemberCategory.getClearingMemberCategory();
-            if (IEnumKey.contains(clearingCategoryValue, ClearingCategory.B, ClearingCategory.I, ClearingCategory.V)) {
-                servicePredicate = relationPredicateBuilder.equals("service", ru.spcex.platform.enumeration.Service.MKR.getKey());
-            } else if (IEnumKey.contains(clearingCategoryValue, ClearingCategory.F, ClearingCategory.C)) {
-                servicePredicate = relationPredicateBuilder.equals("service", ru.spcex.platform.enumeration.Service.FOND.getKey());
-            } else {
-                log.info("ClearingCategoryNotFound with clearingCategoryValue={} not implemented. Do not search Relation.", clearingCategoryValue);
-                return null;
-            }
-            finalRelationPredicate = relationPredicateBuilder.and(consumerIdPredicate, servicePredicate);
-            relations = relationMap.getCollectionObjectsByPredicate(finalRelationPredicate);
-        } else {
-            finalRelationPredicate = relationPredicateBuilder.equals("consumerId", companyId);
-            relations = relationMap.getCollectionObjectsByPredicate(finalRelationPredicate);
-        }
-
-        if (relations.isEmpty()) {
-            log.info("Relation not found: {}", finalRelationPredicate.toString());
-            return null;
-        }
-        if (relations.size() > 1)
-            log.warn("Relation for consumerId {} contains multiply elements, use first", companyId);
-        Relation relation = relations.iterator().next();
-        account.setRelationId(relation.getId());
-
-        return null;
-    }
-
     private RequestInfoUpdate makeError(Long reqId, AccountError accountError, Object... args) {
         String errMsg = messageResolver.resolve(new EnumMessage(accountError, args));
         return new RequestInfoUpdate()

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

@@ -0,0 +1,122 @@
+package ru.spcex.clearing.account.service;
+
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.account.*;
+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.AccountSymbolsNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest;
+import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.platform.messaging.service.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.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.validation.IValidator;
+
+import java.util.function.Function;
+
+@Service
+public class AccountSymbolsService extends QueueConsumer implements InitializingBean {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private final ValidationHelper validationHelper;
+    private final UserRoleVerification userRoleVerification;
+
+    private final ImdgProvider imdgProvider;
+    private final Imdg<AccountSymbols> accountSymbolsImdg;
+
+    private final RequestHelper requestHelper;
+    private final Function<AccountSymbolsNewRequest, IValidator> accountSymbolsNewRequestValidator;
+
+    private final IMessageResolver messageResolver;
+    private final Producer<String, Object> kafkaProducer;
+    private final KafkaSender kafkaSender;
+
+    public AccountSymbolsService(Consumer<String, Object> kafkaQueue,
+                                 Producer<String, Object> kafkaProducer,
+                                 KafkaSender kafkaSender,
+                                 ImdgProvider imdgProvider,
+                                 ValidationHelper validationHelper,
+                                 UserRoleVerification userRoleVerification,
+                                 IMessageResolver messageResolver,
+                                 RequestHelper requestHelper,
+                                 @Qualifier("accountSymbolsDepoNewRequest")
+                                         Function<AccountSymbolsNewRequest, IValidator> accountSymbolsNewRequestValidator
+    ) {
+        super(kafkaQueue, kafkaProducer);
+        this.kafkaProducer = kafkaProducer;
+        this.kafkaSender = kafkaSender;
+        this.validationHelper = validationHelper;
+        this.userRoleVerification = userRoleVerification;
+        this.requestHelper = requestHelper;
+        this.imdgProvider = imdgProvider;
+        this.accountSymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountSymbols, AccountSymbols.class);
+        this.accountSymbolsNewRequestValidator = accountSymbolsNewRequestValidator;
+        this.messageResolver = messageResolver;
+    }
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        imdgProvider.waitAvailable();
+        callback(AccountSymbolsNewRequest.class)
+                .setFunction(this::accountSymbolsNew)
+                .forDestination(Consts.DESTINATION_DEPO_ACCOUNT_SYMBOLS_NEW, callbacks::put);
+        callback(CommonIdRequest.class)
+                .setFunction(this::accountSymbolsDelete)
+                .forDestination(Consts.DESTINATION_DEPO_ACCOUNT_SYMBOLS_DELETE, callbacks::put);
+        init();
+    }
+
+    protected RequestInfoUpdate accountSymbolsNew(BaseRequest<AccountSymbolsNewRequest> userRequest) {
+        log.debug("AccountSymbolsNewRequest received, id={}", userRequest.getId());
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, accountSymbolsNewRequestValidator);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        AccountSymbolsNewRequest req = userRequest.getRequestPayload();
+
+        Long id = accountSymbolsImdg.nextIDSequenceFor();
+        AccountSymbols accountSymbols = new AccountSymbols();
+        accountSymbols.setId(id);
+        accountSymbols.setAccountId(req.getAccountId());
+        accountSymbols.setAccountSymbolValue(req.getAccountSymbolValue());
+
+        accountSymbolsImdg.insert(accountSymbols);
+
+        log.debug("successfully processed, id {}. New accountSymbols.id={} was created", id, accountSymbols.getId());
+        return null;
+    }
+
+    protected RequestInfoUpdate accountSymbolsDelete(BaseRequest<CommonIdRequest> userRequest) {
+        log.debug("AccountSymbolsDeleteRequest(CommonIdRequest) received, id={}", userRequest.getId());
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        CommonIdRequest req = userRequest.getRequestPayload();
+
+        AccountSymbols accountSymbols = accountSymbolsImdg.getSingleObjectByID(req.getId());
+        if (accountSymbols == null) {
+            return requestHelper.makeErrorResponse(userRequest, AccountError.AccountNotFound, req.getId());
+        }
+
+        accountSymbolsImdg.delete(accountSymbols);
+
+        log.debug("successfully processed, id {}. New accountSymbols.id={} was deleted", userRequest.getId(), accountSymbols.getId());
+        return null;
+    }
+
+}

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

@@ -41,7 +41,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
     private final UserRoleVerification userRoleVerification;
     private final ValidationHelper validationHelper;
 
-    private final AccountService accountService;
+    private final AccountHelper accountService;
 
     private final Function<BankAccountNewRequest, IValidator> bankAccountNewRequestValidator;
     private final Function<BankAccountUpdateRequest, IValidator> bankAccountUpdateRequestValidator;
@@ -53,7 +53,7 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
                               ImdgProvider imdgProvider,
                               UserRoleVerification userRoleVerification,
                               ValidationHelper validationHelper,
-                              AccountService accountService,
+                              AccountHelper accountService,
                               @Qualifier("bankAccountNewRequestValidator")
                                       Function<BankAccountNewRequest, IValidator> bankAccountNewRequestValidator,
                               @Qualifier("bankAccountUpdateRequestValidator")
@@ -221,6 +221,7 @@ 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,7 @@
 package ru.spcex.clearing.account.service;
 
+import org.apache.commons.lang3.tuple.MutableTriple;
+import org.apache.commons.lang3.tuple.Triple;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -10,6 +12,13 @@ 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.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.Notification;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.sdf.SDf52;
+import ru.clearing.platform.dictionary.ClearingCategoryDictionary;
 import ru.spcex.clearing.account.errors.AccountError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
@@ -20,35 +29,39 @@ 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.registry.TradingClearingRegistryUpdateRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.utilities.NotificationFeedbackRequest;
+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.util.services.RequestHelper;
 import ru.spcex.clearing.validation.common.ValidationHelper;
-import ru.spcex.platform.enumeration.AccountType;
-import ru.spcex.platform.enumeration.SdfTable;
-import ru.spcex.platform.enumeration.ServiceStatus;
-import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.ImdgTransaction;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.utils.collection.Pair;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IErrorEnumId;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.validation.IValidator;
 
 import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
+
 @Service
 public class ClearingAccountService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final KafkaSender kafkaSender;
-    private final AccountService accountService;
+    private final AccountHelper accountService;
+    private final SDFProcessService sdfProcessService;
     private final ValidationHelper validationHelper;
     private final ImdgProvider imdgProvider;
     private final IMessageResolver messageResolver;
@@ -56,11 +69,21 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
     private final Function<ClearingAccountNewRequest, IValidator> clearingAccountNewRequestValidator;
     private final Function<ClearingAccountUpdateRequest, IValidator> clearingAccountUpdateRequestValidator;
 
+    private final Imdg<Account> accountImdg;
+    private final Imdg<ClearingAccount> clearingAccountImdg;
+    private final Imdg<Company> companyImdg;
+    private final Imdg<Relation> relationImdg;
+    private final Imdg<ClearingMemberCategory> clearingMemberCategoryImdg;
+    private final Imdg<ClearingCategoryDictionary> clearingCategoryImdg;
+    private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
+    private final Imdg<Notification> notificationImdg;
+
     @Autowired
     public ClearingAccountService(Consumer<String, Object> kafkaQueue,
                                   Producer<String, Object> kafkaResponseQueue,
                                   KafkaSender kafkaSender,
-                                  AccountService accountService,
+                                  AccountHelper accountService,
+                                  SDFProcessService sdfProcessService,
                                   ValidationHelper validationHelper,
                                   ImdgProvider imdgProvider,
                                   IMessageResolver messageResolver,
@@ -72,12 +95,22 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         super(kafkaQueue, kafkaResponseQueue);
         this.kafkaSender = kafkaSender;
         this.accountService = accountService;
+        this.sdfProcessService = sdfProcessService;
         this.validationHelper = validationHelper;
         this.imdgProvider = imdgProvider;
         this.messageResolver = messageResolver;
         this.requestHelper = requestHelper;
         this.clearingAccountNewRequestValidator = clearingAccountNewRequestValidator;
         this.clearingAccountUpdateRequestValidator = clearingAccountUpdateRequestValidator;
+
+        this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.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);
+        this.clearingMemberCategoryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class);
+        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);
     }
 
     @Override
@@ -92,6 +125,13 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
                 .setFunction(this::accountNewSdf01)
                 .forDestination(Consts.ACCOUNT_NEW_SDF01, callbacks::put);
 
+        callback(StatementRequest.class)
+                .setFunction(this::accountUpdateSdf52)
+                .forDestination(Consts.ACCOUNT_PROCESS_SDF52, callbacks::put);
+        callback(NotificationFeedbackRequest.class)
+                .setFunction(this::accountUpdateSdf52_part2Notification)
+                .forDestination(Consts.ACCOUNT_NOTIFICATION_FEEDBACK, callbacks::put);
+
         init();
     }
 
@@ -106,7 +146,8 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         Instant now = Instant.now();
         Account account = new Account();
         account.setAccount(req.getAccount());
-        account.setAccountType(AccountType.Clrn.getKey());if (req.getStatus() == null) {
+        account.setAccountType(AccountType.Clrn.getKey());
+        if (req.getStatus() == null) {
             account.setStatus(WorkflowStatus.Active.getKey());
             log.trace("Status not set in request. Use default: {}", account.getStatus());
         } else {
@@ -221,18 +262,18 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
                 account.setUpdated(now);
                 RequestInfoUpdate requestInfoUpdate = accountService.fillAccountFromRelation(account, userRequest.getId(), true);
                 if (requestInfoUpdate != null) {
-                    log.warn("Error fill new account from relation. {}", requestInfoUpdate.getMessage());
+                    log.warn("Error fill new account from relation. {}", /*account.getId(),*/ requestInfoUpdate.getMessage());
                     {
                         AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
                         responsePart.setSdfId(accountReq.getSdfId());
-                        responsePart.setErrorCode(AccountError.ClearingCategoryNotFound.getId());
+                        responsePart.setErrorCode(AccountError.ClearingCategoryNotFound.getId()); // see accountService.fillAccountFromRelation
                         responsePart.setErrorText(requestInfoUpdate.getMessage());
                         accountToStatement.add(responsePart);
                         continue accountsLoop;
                     }
                 }
 
-                if (accountImdg.getFirstObjectBySQL("accountType = '%s' and account = '%s'".formatted(AccountType.Clrn.getKey(), accountReq.getAccount())) != null) {
+                if (accountImdg.getFirstObjectBySQL("account = '%s'".formatted(accountReq.getAccount())) != null) {
                     log.debug("Account {} already exists", accountReq.getAccount());
                     {
                         AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
@@ -275,19 +316,302 @@ public class ClearingAccountService extends QueueConsumer implements Initializin
         }
 
 
-        sendStatementRequestBack(req.getGroupingSdf01Id(), accountToStatement);
+        sendStatementRequestBack(req.getGroupingSdf01Id(), req.getGroupingSdf02Id(), accountToStatement);
         log.debug("successfully processed, grouping id={}, processed number={}", req.getGroupingSdf01Id(), accountToStatement.size());
 
         return null;
     }
 
-    public void sendStatementRequestBack(Long groupingSdf01Id, List<AccountSdfToStatementRequestPart> results) {
+    public RequestInfoUpdate accountUpdateSdf52(BaseRequest<StatementRequest> systemRequest) {
+        log.debug("accountUpdateSdf52 StatementRequest received, id={}", systemRequest.getId());
+
+        StatementRequest req = systemRequest.getRequestPayload();
+        Long groupId = req.getGroupId();
+        if (SdfTable.SDF_52 != req.getTable()) {
+            log.warn("Unsupported table {} received on accountUpdateSdf52. Expected only {}.",
+                    req.getTable(), SdfTable.SDF_52);
+        }
+        Collection<SDf52> sdfs = sdfProcessService.sdfsByGroupId(groupId);
+        if (sdfs.isEmpty()) {
+            log.info("Do not processing SDF52: S_DF52 not found by groupId={}", groupId);
+            return null;
+        }
+        log.info("start processing {} SDF52: groupId={}", sdfs.size(), groupId);
+
+        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)));
+                    continue;
+                }
+                Company company = sDf52.getDeal() == null ? null : companyImdg.getSingleObjectByFieldValues(Map.of("tradingCode", sDf52.getDeal()));
+                if (company == null) {
+                    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)));
+                    continue;
+                }
+                Map<String, Comparable<?>> accountQuery = Map.of(
+                        "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);
+                    } 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)));
+                        continue;
+                    }
+                }
+                toProcessSDF53.add(new MutableTriple<>(sDf52, account, SDFProcessService.SDF_STATUS_OK));
+                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
+                throw new IllegalArgumentException("Can not parse sdf status " + sdf.getStatus());
+            }
+            if (newStatus.equalsByKey(account.getStatus())) {
+                // одинаковых обычно не бывает.
+                continue;
+            }
+            if (AccountStatus.BLOCKED == newStatus || AccountStatus.CLOSE == newStatus) { // статус 0/2
+                sendNotificationRequest(ObjectType.account_block, account, newStatus);
+                notificationAccountIds.add(account.getId());
+                putNotificationWaiting(systemRequest, item.getFirst(), item.getSecond());
+            }
+            if (AccountStatus.ACTIVE == newStatus) { // статус 1/3
+                sendNotificationRequest(ObjectType.account_active, account, newStatus);
+                notificationAccountIds.add(account.getId());
+                putNotificationWaiting(systemRequest, item.getFirst(), item.getSecond());
+            }
+        }
+        sdfProcessService.process(req, toProcessSDF53);
+
+        log.info("{} account's need wait accept over notification. GroupId={}", notificationAccountIds.size(), groupId);
+
+        log.debug("successfully processed, grouping id={} with {} accounts.",
+                groupId, toUpdate.size());
+        return null;
+    }
+
+    protected RequestInfoUpdate accountUpdateSdf52_part2Notification(BaseRequest<NotificationFeedbackRequest> secondSystemRequest2) {
+        log.debug("accountUpdateSdf52 NotificationFeedbackRequest received, id={}", secondSystemRequest2.getId());
+        SDF52WaitingData trigger = onNotificationResponse(secondSystemRequest2.getRequestPayload());
+        if (trigger == null) {
+            log.trace("Not triggered, continue waiting");
+            return null;
+        } else {
+            log.debug("Triggered, groupId={}, notification's status: {}, last notification user id={}",
+                    trigger.getGroupId(), trigger.globalStatus, secondSystemRequest2.getUserId());
+            if (NotificationStatus.ACPT.equalsByKey(trigger.globalStatus)) {
+                return accountUpdateSdf52_part2(trigger.systemRequest, trigger.sdf, trigger.account, secondSystemRequest2);
+            } else if (NotificationStatus.CNCL.equalsByKey(trigger.globalStatus)) {
+                log.debug("groupId={} rejected by user {}.", trigger.getGroupId(), secondSystemRequest2.getUserId());
+                return null;
+            } else {
+                log.warn("Unknown waiting group status \"{}\"", trigger.globalStatus);
+                return null;
+            }
+        }
+    }
+
+    protected RequestInfoUpdate accountUpdateSdf52_part2(BaseRequest<StatementRequest> systemRequest1,
+                                                         SDf52 sdf, Account account,
+                                                         BaseRequest<NotificationFeedbackRequest> secondSystemRequest2) {
+        // 5. from notification:
+        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());
+
+        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) { // счёт заблокировали - значит блокируем ТКР, наоборот не надо.
+                // Отправка в ТКР
+                TradingClearingRegistryUpdateRequest tcrReq = new TradingClearingRegistryUpdateRequest();
+                tcrReq.setMoneyAccountId(account.getId());
+                tcrReq.setCompanyId(account.getCompanyId());
+                tcrReq.setStatus(account.getStatus());
+                Map<String, Long> queryTCR = new HashMap<>();
+                queryTCR.put("moneyAccountId", tcrReq.getMoneyAccountId());
+                if (tcrReq.getCompanyId() != null)
+                    queryTCR.put("companyId", tcrReq.getCompanyId());
+                TradingClearingRegistry tcr = tradingClearingRegistryImdg.getFirstObjectByFieldValues(queryTCR);
+                if (tcr == null) {
+                    log.warn("TradingClearingRegistry by {} not found, do not send update TCR.", queryTCR);
+                } else {
+                    tcrReq.setId(tcr.getId());
+                    String destination = Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE;
+                    log.debug("Send message to kafka \"{}\": {}", destination, LogFormatter.toStringWrapper(tcrReq));
+                    kafkaSender.sendRequestToQueue(destination, tcrReq);
+                }
+            }
+            countOfUpdated++;
+        } else {
+            log.info("Account[{}] \"{}\" do not updated - same status \"{}\"", account.getId(), account.getAccount(), newStatus);
+        }
+
+        log.debug("successfully processed, grouping id={}. Updated {} accounts.",
+                groupId, countOfUpdated);
+        return null;
+    }
+
+    protected String makeSdfErrorText(IErrorEnumId clrError, String sdfCode) {
+        if (clrError == null) return sdfCode;
+        sdfCode = clrError.getId().toString();
+        if (sdfCode.length() > 3)
+            sdfCode = sdfCode.substring(sdfCode.length() - 3);
+        return sdfCode;
+    }
+
+    public void sendStatementRequestBack(Long groupingSdf01Id, Long groupSdf02Id, List<AccountSdfToStatementRequestPart> results) {
+        final String destination = Consts.STATEMENT_PROCESS;
         StatementRequest request = new StatementRequest();
         request.setGroupId(groupingSdf01Id);
+        request.setChildGenerationId(groupSdf02Id);
         request.setAccountCreationResults(results);
         request.setContinueSdf(true);
-        request.setTable(SdfTable.SDF_01);
-        log.debug("Send message to kafka \"{}\": {}", Consts.STATEMENT_PROCESS, LogFormatter.toStringWrapper(request));
-        kafkaSender.sendRequestToQueue(Consts.STATEMENT_PROCESS, request);
+        request.setTable(SdfTable.SDF_01); // по нему запрос получили
+        log.debug("Send message to kafka \"{}\": {}", destination, LogFormatter.toStringWrapper(request));
+        kafkaSender.sendRequestToQueue(destination, request);
+    }
+
+    public Long sendNotificationRequest(ObjectType objectType, Account account, AccountStatus requestToStatus) {
+        String statusText = AccountStatus.BLOCKED == requestToStatus ? "Заблокирован"
+                : AccountStatus.CLOSE == requestToStatus ? "Закрыт"
+                : AccountStatus.ACTIVE == requestToStatus ? "Разблокирован" :
+                requestToStatus.getKey();
+        String message = String.format("Для счета %s будет изменен статус на «%s»", account.getAccount(), statusText);
+        final String destination = Consts.NOTIFICATION_NEW;
+        NotificationNewRequest request = new NotificationNewRequest();
+        request.setObjectType(objectType.getKey());
+        request.setObjectId(account.getId());
+        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;
+    }
+
+
+    // --------- notification apply system -----------
+    public static class SDF52WaitingData {
+        public BaseRequest<StatementRequest> systemRequest;
+        public SDf52 sdf;
+        public Account account;
+        public Long notAnsweredAccountId;
+        public String globalStatus;
+
+        public SDF52WaitingData(BaseRequest<StatementRequest> systemRequest, SDf52 sdf, Account account) {
+            this.systemRequest = systemRequest;
+            this.sdf = sdf;
+            this.account = account;
+            this.notAnsweredAccountId = account.getId();
+        }
+
+        public Long getGroupId() {
+            if (systemRequest != null && systemRequest.getRequestPayload() != null)
+                return systemRequest.getRequestPayload().getGroupId();
+            return null;
+        }
+    }
+
+    protected ConcurrentHashMap<Long, SDF52WaitingData> waitingList = new ConcurrentHashMap<>();
+
+    public boolean putNotificationWaiting(BaseRequest<StatementRequest> systemRequest, SDf52 sdf, Account account) {
+        SDF52WaitingData data = new SDF52WaitingData(systemRequest, sdf, account);
+        if (waitingList.contains(data.notAnsweredAccountId)) {
+            log.warn("groupId={} accountId={} already waiting", data.getGroupId(), data.notAnsweredAccountId);
+        }
+        data.globalStatus = null;
+        waitingList.put(data.notAnsweredAccountId, data);
+        return true;
+    }
+
+    /**
+     * @return triggered SDF52WaitingData or null
+     */
+    public SDF52WaitingData onNotificationResponse(NotificationFeedbackRequest onNotification) {
+        if (onNotification.getNotificationId() == null) {
+            log.trace("notificationId was empty");
+            return null;
+        }
+        Notification notification = notificationImdg.getSingleObjectByID(onNotification.getNotificationId());
+        if (notification == null) {
+            log.warn("Notification with id={} not exist", onNotification.getNotificationId());
+            return null;
+        }
+        if (!ObjectType.account_active.equalsByKey(notification.getObjectType()) && !ObjectType.account_block.equalsByKey(notification.getObjectType())) {
+            log.warn("Notification[{}].objectType={} not supported", notification.getId(), notification.getObjectType());
+            return null;
+        }
+        if (notification.getObjectId() == null) {
+            log.warn("Notification[{}] with empty objectId", notification.getId());
+            return null;
+        }
+        final Long accountId = notification.getObjectId();
+        log.trace("Match accountId={} by notificationId={}", accountId, notification.getId());
+        SDF52WaitingData inWaitingLst = waitingList.get(accountId);
+        if (inWaitingLst == null) {
+            log.debug("SDF52 waiting list (count {}) not found for accountId={}", waitingList.size(), accountId);
+            return null;
+        }
+        boolean returnTrigger = false;
+        if (NotificationStatus.ACPT.equalsByKey(onNotification.getNotificationStatus())) {
+            log.trace("Triggered ACPT, by accountId={}", accountId);
+            inWaitingLst.globalStatus = onNotification.getNotificationStatus();
+            returnTrigger = true;
+        } else if (NotificationStatus.CNCL.equalsByKey(onNotification.getNotificationStatus())) {
+            log.trace("Triggered CNCL, by accountId={}", accountId);
+            inWaitingLst.globalStatus = onNotification.getNotificationStatus();
+            returnTrigger = true;
+        } else {
+            log.warn("Unknown notification[{}] status={}", onNotification.getNotificationId(), onNotification.getNotificationStatus());
+        }
+        if (returnTrigger) {
+            log.debug("Remove from waiting list accountId={} (list groupId={})", accountId, inWaitingLst.getGroupId());
+            waitingList.remove(inWaitingLst);
+        }
+        if (returnTrigger)
+            return inWaitingLst;
+        else
+            return null;
     }
 }

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

@@ -115,8 +115,18 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
 
     }
 
+    /**
+     * Проверки
+     * 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) {
+        if (moneyAccountId == null) { // Если не заполнены moneyAccountId ИЛИ moneyAccountId и depoAccountId
             EnumMessage error = null;
             if (companyId == null) {
                 error = new EnumMessage(AccountError.RequiredFieldEmpty, "companyId");
@@ -143,6 +153,7 @@ 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;
 
@@ -179,6 +190,7 @@ 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;
 
@@ -212,6 +224,7 @@ 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;
 
@@ -284,6 +297,7 @@ public class ClientCodeService extends QueueConsumer implements InitializingBean
     }
 
     private boolean checkNeedCreateTCR(Long companyId, Long moneyAccountId, Long depoAccountId) {
+        // moneyAccountId обязателен, depoAccountId опционален
         if (moneyAccountId == null) {
             return false;
         }
@@ -307,8 +321,11 @@ 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());
@@ -338,6 +355,11 @@ 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) {
@@ -361,8 +383,13 @@ 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());
 

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

@@ -23,10 +23,7 @@ import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.clearing.validation.common.ValidationHelper;
-import ru.spcex.platform.enumeration.AccountType;
-import ru.spcex.platform.enumeration.SdfTable;
-import ru.spcex.platform.enumeration.ServiceStatus;
-import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.ImdgTransaction;
@@ -44,7 +41,7 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
     private final KafkaSender kafkaSender;
     private final ValidationHelper validationHelper;
     private final ImdgProvider imdgProvider;
-    private final AccountService accountService;
+    private final AccountHelper accountService;
     private final Function<DepoAccountNewRequest, IValidator> depoAccountNewRequestValidator;
 
     public DepoAccountService(Consumer<String, Object> kafkaQueue,
@@ -52,7 +49,7 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
                               KafkaSender kafkaSender,
                               ValidationHelper validationHelper,
                               ImdgProvider imdgProvider,
-                              AccountService accountService,
+                              AccountHelper accountService,
                               @Qualifier("depoAccountNewRequestValidator")
                                       Function<DepoAccountNewRequest, IValidator> depoAccountNewRequestValidator) {
         super(kafkaQueue, kafkaProducer);
@@ -114,7 +111,11 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
             depoAccount = new DepoAccount();
             depoAccount.setCompanyId(req.getCompanyId());
             depoAccount.setAccountId(accountId);
-            depoAccount.setDepoAccountType(req.getDepoAccountType());
+            if (account.getAccount() != null && account.getAccount().contains("BC")) {
+                depoAccount.setDepoAccountType(DepoAccountType.C.getKey());
+            } else {
+                depoAccount.setDepoAccountType(req.getDepoAccountType());
+            }
             depoAccountId = depoAccountImdg.insert(depoAccount);
             txOk = true;
         } finally {
@@ -146,6 +147,8 @@ 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());
@@ -156,17 +159,17 @@ 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. {}", requestInfoUpdate.getMessage());
+                    log.warn("Error fill new account from relation. {}", /*account.getId(),*/ requestInfoUpdate.getMessage());
                     {
                         AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
                         responsePart.setSdfId(accountReq.getSdfId());
-                        responsePart.setErrorCode(AccountError.ClearingCategoryNotFound.getId());
+                        responsePart.setErrorCode(AccountError.ClearingCategoryNotFound.getId()); // see accountService.fillAccountFromRelation
                         responsePart.setErrorText(requestInfoUpdate.getMessage());
                         accountToStatement.add(responsePart);
                         continue accountsLoop;
                     }
                 }
-                if (accountImdg.getFirstObjectBySQL("accountType = '%s' and account = '%s'".formatted(AccountType.Depo.getKey(), accountReq.getAccount())) != null) {
+                if (accountImdg.getFirstObjectBySQL("account = '%s'".formatted(accountReq.getAccount())) != null) {
                     log.debug("Account {} already exists", accountReq.getAccount());
                     {
                         AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
@@ -186,7 +189,11 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
                 DepoAccount depoAccount = new DepoAccount();
                 depoAccount.setCompanyId(accountReq.getCompanyId());
                 depoAccount.setAccountId(accountId);
-                depoAccount.setDepoAccountType(accountReq.getAccountType());
+                if (account.getAccount() != null && account.getAccount().contains("BC")) {
+                    depoAccount.setDepoAccountType(DepoAccountType.C.getKey());
+                } else {
+                    depoAccount.setDepoAccountType(accountReq.getAccountType());
+                }
                 depoAccountId = depoAccountImdg.insert(depoAccount);
 
 
@@ -211,18 +218,19 @@ public class DepoAccountService extends QueueConsumer implements InitializingBea
             }
         }
 
-        sendStatementRequestBack(req.getGroupingSdf01Id(), accountToStatement);
+        sendStatementRequestBack(req.getGroupingSdf01Id(), req.getGroupingSdf02Id(), accountToStatement);
         log.debug("successfully processed, grouping id={}, processed number={}", req.getGroupingSdf01Id(), accountToStatement.size());
 
         return null;
     }
 
-    public void sendStatementRequestBack(Long groupingSdf01Id, List<AccountSdfToStatementRequestPart> results) {
+    public void sendStatementRequestBack(Long groupingSdf01Id, Long groupingSdf02Id, List<AccountSdfToStatementRequestPart> results) {
         StatementRequest request = new StatementRequest();
         request.setGroupId(groupingSdf01Id);
-        request.setContinueSdf(true);
+        request.setChildGenerationId(groupingSdf02Id);
+        request.setContinueSdf(true); //fixme????
         request.setAccountCreationResults(results);
-        request.setTable(SdfTable.SDF_08);
+        request.setTable(SdfTable.SDF_08); // по нему запрос получили
         log.debug("Send message to kafka \"{}\": {}", Consts.STATEMENT_PROCESS, LogFormatter.toStringWrapper(request));
         kafkaSender.sendRequestToQueue(Consts.STATEMENT_PROCESS, request);
     }

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

@@ -16,11 +16,13 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.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;
 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.AccountType;
@@ -49,13 +51,18 @@ public class InformationAccountService extends QueueConsumer implements Initiali
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final KafkaSender kafkaSender;
     private final IMessageResolver messageResolver;
+    private final UserRoleVerification userRoleVerification;
     private final ImdgProvider imdgProvider;
     private final ValidationHelper validationHelper;
-    private final AccountService accountService;
+    private final AccountHelper accountHelper;
     private final RequestHelper requestHelper;
     private final Function<InformationAccountNewRequest, IValidator> infoAccountNewRequestValidator;
     private final Imdg<InformationAccount> informationAccountImdg;
     private final Imdg<Account> accountImdg;
+    /**
+     * Кэш-счётчик сквозных номеров счетов.
+     * См. accountNextId()
+     */
     protected AtomicLong infoCounter;
 
     @Autowired
@@ -63,18 +70,20 @@ public class InformationAccountService extends QueueConsumer implements Initiali
                                      Producer<String, Object> kafkaResponseQueue,
                                      KafkaSender kafkaSender,
                                      IMessageResolver messageResolver,
+                                     UserRoleVerification userRoleVerification,
                                      ImdgProvider imdgProvider,
                                      ValidationHelper validationHelper,
-                                     AccountService accountService,
+                                     AccountHelper accountHelper,
                                      RequestHelper requestHelper,
                                      @Qualifier("informationAccountNewRequestValidator")
                                              Function<InformationAccountNewRequest, IValidator> infoAccountNewRequestValidator) {
         super(kafkaQueue, kafkaResponseQueue);
         this.kafkaSender = kafkaSender;
         this.messageResolver = messageResolver;
+        this.userRoleVerification = userRoleVerification;
         this.imdgProvider = imdgProvider;
         this.validationHelper = validationHelper;
-        this.accountService = accountService;
+        this.accountHelper = accountHelper;
         this.requestHelper = requestHelper;
         this.infoAccountNewRequestValidator = infoAccountNewRequestValidator;
         this.informationAccountImdg = imdgProvider.getImdg(
@@ -96,10 +105,13 @@ public class InformationAccountService extends QueueConsumer implements Initiali
         init();
     }
 
+    @Deprecated
     public RequestInfoUpdate informationAccountNew(BaseRequest<InformationAccountNewRequest> userRequest) {
         log.debug("InformationAccountNewRequest received");
 
-        RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, infoAccountNewRequestValidator);
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, infoAccountNewRequestValidator);
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
         InformationAccountNewRequest req = userRequest.getRequestPayload();
@@ -123,7 +135,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali
 
         Instant now = Instant.now();
         Account account = new Account();
-        account.setAccount(accountValue);
+        account.setAccount(req.getAccount());
         account.setAccountType(AccountType.Info.getKey());
         if (req.getStatus() == null) {
             account.setStatus(WorkflowStatus.Active.getKey());
@@ -134,7 +146,8 @@ public class InformationAccountService extends QueueConsumer implements Initiali
         account.setCompanyId(req.getCompanyId());
         account.setCreated(now);
         account.setUpdated(now);
-        requestInfoUpdate = accountService.fillAccountFromRelation(account, userRequest.getId(), true);
+
+        requestInfoUpdate = accountHelper.fillAccountFromRelation(account, userRequest.getId(), true);
         if (requestInfoUpdate != null) return requestInfoUpdate;
 
         ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
@@ -178,10 +191,12 @@ 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()
@@ -195,7 +210,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali
 
 
         Long newId = informationAccountImdg.nextIDSequenceFor();
-        Long infoSequenceId = accountNextId();
+        Long infoSequenceId = accountNextId(); // требуется последовательность n+1
         String accountValue = generateInfoAccount(infoSequenceId);
         log.trace("New info-account id={}, sequenceId={}, account={}", newId, infoSequenceId, accountValue);
 
@@ -224,7 +239,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali
         account.setCompanyId(forCompanyId);
         account.setCreated(now);
         account.setUpdated(now);
-        requestInfoUpdate = accountService.fillAccountFromRelation(account, userRequest.getId(), false);
+        requestInfoUpdate = accountHelper.fillAccountFromRelation(account, userRequest.getId(), false);
         if (requestInfoUpdate != null) {
             log.debug("Stop make new account, cause error: {}", requestInfoUpdate.getMessage());
             return requestInfoUpdate;
@@ -261,12 +276,17 @@ public class InformationAccountService extends QueueConsumer implements Initiali
                 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());
@@ -279,7 +299,12 @@ public class InformationAccountService extends QueueConsumer implements Initiali
     }
 
 
-    protected Long accountNextId() {
+    /**
+     * Сквозной номер инфо-счетов
+     *
+     * @return infoCounter++
+     */
+    public synchronized Long accountNextId() {
         if (infoCounter == null) synchronized (this) {
             if (infoCounter == null) {
                 log.debug("Init account-information counter.");
@@ -291,7 +316,7 @@ public class InformationAccountService extends QueueConsumer implements Initiali
                     Pattern accPattern = Pattern.compile("39911810([0-9]{8})7000");
                     int maxN = 1;
                     int parsedCount = 0;
-                    String lastAccount = null;
+                    String lastAccount = null; // for debug
                     for (Account acc : allInfoAcc) {
                         try {
                             String number = acc.getAccount();

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

@@ -0,0 +1,160 @@
+package ru.spcex.clearing.account.service;
+
+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).
+
+    protected static final Long SDF52_STATUS_0Blocked = 0L;
+    protected static final Long SDF52_STATUS_1Unblocked = 1L;
+    protected static final Long SDF52_STATUS_2Closed = 2L;
+    protected static final Long SDF52_STATUS_3Open = 3L;
+
+    final protected Logger log = LoggerFactory.getLogger(getClass());
+
+    protected final Producer<String, Object> kafkaResponseQueue;
+    protected final KafkaSender kafkaSender;
+
+    protected final ImdgProvider imdgProvider;
+    protected final ImdgId idGenerator;
+
+    private final Imdg<SDf52> sdf52Imdg;
+
+    public SDFProcessService(
+            Producer<String, Object> kafkaResponseQueue,
+            KafkaSender kafkaSender,
+            ImdgProvider imdgProvider) {
+        this.kafkaResponseQueue = kafkaResponseQueue;
+        this.kafkaSender = kafkaSender;
+        this.imdgProvider = imdgProvider;
+        this.idGenerator = imdgProvider.getImdgIdGenerator();
+
+        this.sdf52Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf52, SDf52.class);
+    }
+
+    public Collection<SDf52> sdfsByGroupId(Long generationId) {
+        Collection<SDf52> sdfs = sdf52Imdg.getCollectionObjectsByFieldValues(Map.of(
+                "generationId", generationId
+        ));
+        return sdfs;
+    }
+
+    public void process(StatementRequest req, List<Triple<SDf52, Account, String>> toProcessSDF53) {
+        final Long generationId = req.getGroupId();
+        log.info("Create S_DF53 generationId={} by {} S_DF_52",
+                generationId, toProcessSDF53.size());
+        ImdgTransaction imdgTransaction = imdgProvider.newTransaction();
+        boolean txOk = false;
+        imdgTransaction.beginTransaction();
+        HashSet<String> fileNames = new HashSet<>();
+        try { // 2. обновление данных, в транзакции
+            Imdg<SDf53> sdf53Imdg = imdgTransaction.getImdg(IMDGDistributedNames.Map_SDf53, SDf53.class);
+
+            Instant now = Instant.now();
+            for (Triple<SDf52, Account, String> item : toProcessSDF53) {
+                SDf53 sDf53 = createBy(item.getLeft(), item.getRight(), now, generationId);
+                sdf53Imdg.insert(sDf53);
+                fileNames.add(item.getLeft().getFileName());
+            }
+
+            txOk = true;
+        } finally {
+            if (txOk) {
+                imdgTransaction.commitTransaction();
+            } else {
+                log.debug("failed create new SDF53, rollback transaction. sdf52 generationId={}", generationId);
+                imdgTransaction.rollbackTransaction();
+            }
+        }
+
+        if (fileNames.size() > 1)
+            log.warn("generationId={}, too many different file names in S_DF52: {}", generationId, fileNames);
+        String fileNameSingle = fileNames.stream().filter(Objects::nonNull).findAny().orElse(null);
+        log.info("Send export command for SDF53 generationId={} with source file name {}",
+                generationId, (fileNameSingle == null ? null : "\"" + fileNameSingle + "\""));
+        messageStatementToExport53(generationId, fileNameSingle);
+    }
+
+    SDf53 createBy(SDf52 sdf52, String result, Instant now, Long newGenerationId) {
+        SDf53 newSdf = new SDf53();
+        newSdf.setId(idGenerator.nextId());
+        newSdf.setAccName(sdf52.getAcc_name());
+        newSdf.setAccount(sdf52.getAccount());
+        newSdf.setDeal(sdf52.getDeal());
+        newSdf.setDate(sdf52.getDate());
+        newSdf.setStatus(sdf52.getStatus());
+        newSdf.setResult(result);
+        newSdf.setGenerationTime(now);
+        newSdf.setGenerationId(sdf52.getGenerationId());
+        if (!Objects.equals(newGenerationId, newSdf.getGenerationId())) { // never
+            log.warn("Different GenerationId={} for sdf53[{}] and GenerationId={} for group of sdf52",
+                    newSdf.getGenerationId(), newSdf.getId(), newGenerationId
+            );
+        }
+        newSdf.setInSDfId(sdf52.getId());
+        return newSdf;
+    }
+
+
+    /**
+     * @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;
+        } else if (SDF52_STATUS_0Blocked.equals(status)) {
+            return AccountStatus.BLOCKED;
+        }
+        if (SDF52_STATUS_2Closed.equals(status)) {
+            return AccountStatus.CLOSE;
+        }
+        return null;
+    }
+
+
+    void messageStatementToExport53(Long groupId, String fileName) {
+        final String destination = Consts.EXPORT_PROCESS; // dbf-exporter
+        ExportToFileRequest request = new ExportToFileRequest();
+        request.setNameOfTable("DF-53"); // SdfTable.SDF_53
+        request.setSdfGroupId(groupId);
+        request.setFileName(fileName);
+        Long msgId = kafkaSender.sendRequestToQueue(destination, request);
+        log.debug("Send ExportToFileRequest({}, {}) message id={} to kafka \"{}\"",
+                groupId, request.getNameOfTable(), msgId, destination);
+    }
+
+}

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

@@ -99,7 +99,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.relationImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Relation, Relation.class);
         this.tradingClearingRegistryNewRequestValidator = tradingClearingRegistryNewRequestValidator;
-        this.tradingClearingRegistryAutoNewRequestValidator = tradingClearingRegistryNewRequestValidator;
+        this.tradingClearingRegistryAutoNewRequestValidator = tradingClearingRegistryNewRequestValidator; // без relation.
         this.tradingClearingRegistryUpdateRequestValidator = tradingClearingRegistryUpdateRequestValidator;
         this.tradingClearingRegistryBlockRequestValidator = tradingClearingRegistryBlockRequestValidator;
         this.messageResolver = messageResolver;
@@ -108,7 +108,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
     @Override
     public void afterPropertiesSet() throws Exception {
         imdgProvider.waitAvailable();
-        callback(TradingClearingRegistryNewRequest.class)
+        callback(TradingClearingRegistryNewRequest.class) // todo deprecated - unused.
                 .setFunction(this::tradingClearingRegistryAutoNew)
                 .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_AUTO_NEW, callbacks::put);
         callback(TradingClearingRegistryNewRequest.class)
@@ -143,13 +143,18 @@ 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()));
-            Long accountId = req.getMoneyAccountId();
+//        if (clearingAccount == null) infoAccount = informationAccountImdg.getSingleObjectByFieldValues(Map.of("accountId", req.getMoneyAccountId()));
+            Long accountId = req.getMoneyAccountId(); //clearingAccount != null ? clearingAccount.getAccountId() : infoAccount.getAccountId();
             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) {
@@ -189,7 +194,7 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
                 }
                 if (accountId != null) {
                     accountMain = accountImdg.getSingleObjectByID(accountId);
-                    if (accountMain == null) {
+                    if (accountMain == null) { // never, только с инконсистентными данными
                         log.warn("Account {} not exist.", accountId);
                     } else {
                         tradingClearingRegistry.setMoneyAccountId(accountId);
@@ -257,6 +262,9 @@ 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);
 
@@ -277,6 +285,7 @@ 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) {
@@ -385,14 +394,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();
-        String trType = tradingRegistryType + "T";
+        code += registryPurpose.getKey(); // C / M / ...
+        String trType = tradingRegistryType + "T"; // 2 символа
         code += trType;
         String sId = "%5s".formatted(id).replace(' ', '0');
         if (sId.length() > 5)
             sId = sId.substring(sId.length() - 5);
         code += sId;
-        return code;
+        return code; // 12 имволов
     }
 
     public RequestInfoUpdate tradingClearingRegistryUpdate(BaseRequest<TradingClearingRegistryUpdateRequest> userRequest) {
@@ -405,12 +414,16 @@ 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())) {
             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())) {
@@ -448,6 +461,9 @@ public class TradingClearingRegistryService extends QueueConsumer implements Ini
     }
 
 
+    /**
+     * company-service сообщение об успешном добавлении ТКР клиента с параметром tradingClearingRegistry.code
+     */
     protected void sendNotificationToCompanySvc(TradingClearingRegistry tradingClearingRegistry) {
         ClientCodeNewRequest request = new ClientCodeNewRequest();
         request.setTradingClearingRegistryId(tradingClearingRegistry.getId());
@@ -459,6 +475,9 @@ 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());
@@ -467,6 +486,9 @@ 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/validation/AccountValidationRule.java

@@ -29,6 +29,7 @@ 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/test/java/ru/spcex/clearing/account/service/AccountServiceTest.java

@@ -21,14 +21,15 @@ import ru.clearing.platform.dictionary.AccountTypeDictionary;
 import ru.clearing.platform.dictionary.ServiceStatusDictionary;
 import ru.spcex.clearing.account.config.BeanConfiguration;
 import ru.spcex.clearing.account.config.validation.AccountValidationConfig;
+import ru.spcex.clearing.account.config.validation.InformationAccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.ValidationConfig;
-import ru.spcex.clearing.account.utils.MatcherFactory;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.CorrespondentAccountUpdateRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
 import ru.spcex.clearing.platform.messaging.service.RequestInfo;
+import ru.spcex.clearing.test.MatcherFactory;
 import ru.spcex.clearing.test.TestObjectCreator;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
@@ -40,7 +41,7 @@ import javax.annotation.PostConstruct;
 import java.util.Map;
 import java.util.UUID;
 
-import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
 import static ru.spcex.clearing.test.TestUtils.*;
 
 @ExtendWith(SpringExtension.class)
@@ -49,6 +50,9 @@ import static ru.spcex.clearing.test.TestUtils.*;
         ValidationConfig.class,
         AccountValidationConfig.class,
         AccountService.class,
+        AccountHelper.class,
+        InformationAccountService.class,
+        InformationAccountValidationConfig.class,
         ImdgTestConfig.class,
         KafkaTestConfig.class})
 class AccountServiceTest {
@@ -182,16 +186,28 @@ class AccountServiceTest {
 
 
         String jsonString = getJsonStringForUpdate(correspondentAccountUpdateRequest, 0);
+
+        //ACT
         addRecordToKafka((MockConsumer) accountService.getConsumer(),
                 Consts.DESTINATION_CORRESPONDENT_ACCOUNT_UPDATE,
                 PARTITION,
                 0,
                 jsonString);
+
+        //ASSERT
         waitingSendAndCheckRecord(0L, mockProducer);
 
         Account resultUpdating = accountImdg.getSingleObjectByID(accountId);
-        existAccount.setUpdated(resultUpdating.getUpdated());
-        ACCOUNT_MATCHER.assertMatch(resultUpdating, existAccount);
+        Account expectAccount = new Account();
+        expectAccount.setId(existAccount.getId());
+        expectAccount.setAccount(account);
+        expectAccount.setAccountType(AccountType.Corr.getKey());
+        expectAccount.setStatus(ServiceStatus.Closed.getKey());
+        expectAccount.setCompanyId(companyId);
+        expectAccount.setCreated(existAccount.getCreated());
+        expectAccount.setUpdated(resultUpdating.getUpdated());
+        expectAccount.setStatus(ServiceStatus.Active.getKey());
+        ACCOUNT_MATCHER.assertMatch(resultUpdating, expectAccount);
         accountImdg.delete(resultUpdating);
     }
 
@@ -208,11 +224,15 @@ class AccountServiceTest {
         commonDeleteRequest.setId(accountId);
 
         String jsonString = getJsonStringForDelete(commonDeleteRequest, 0);
+
+        //ACT
         addRecordToKafka((MockConsumer) accountService.getConsumer(),
                 Consts.DESTINATION_CORRESPONDENT_ACCOUNT_BLOCK,
                 PARTITION,
                 0,
                 jsonString);
+
+        //ASSERT
         waitingSendAndCheckRecord(0L, mockProducer);
 
         Account resultBlock = accountImdg.getSingleObjectByID(accountId);

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

@@ -0,0 +1,164 @@
+package ru.spcex.clearing.account.service;
+
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.account.*;
+import ru.spcex.clearing.account.config.BeanConfiguration;
+import ru.spcex.clearing.account.config.validation.AccountSymbolsValidationConfig;
+import ru.spcex.clearing.account.config.validation.ValidationConfig;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.AccountSymbolsNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.test.MatcherFactory;
+import ru.spcex.clearing.test.TestObjectCreator;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.test.TestUtils.*;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.setMockFuture;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        BeanConfiguration.class,
+        ValidationConfig.class,
+        AccountSymbolsValidationConfig.class,
+        AccountSymbolsService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class})
+class AccountSymbolsServiceTest {
+    public static final MatcherFactory.Matcher<AccountSymbols> ACCOUNT_SYMBOL_MATCHER = usingIgnoringFieldsComparator();
+    private static final int PARTITION = 0;
+
+    @Autowired
+    AccountSymbolsService accountSymbolsService;
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider hazelcastServiceTest;
+
+    @Autowired
+    @Qualifier("mockProducer")
+    protected Producer<String, Object> mockProducer;
+
+    @Autowired
+    @Qualifier("kafkaTestTemplate")
+    protected KafkaTemplate<String, Object> kafkaTemplate;
+
+    private Imdg<AccountSymbols> accountSymbolsImdg;
+
+    private Imdg<Account> accountImdg;
+    private Long accountId;
+    private Imdg<ClearingAccount> clearingAccountImdg;
+    private Long clearingAccountId;
+
+    static int newRequestCnt = 0;
+
+    @PostConstruct
+    private void init() {
+        hazelcastServiceTest.waitAvailable();
+        accountSymbolsImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_AccountSymbols, AccountSymbols.class
+        );
+        accountImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_Account, Account.class
+        );
+        clearingAccountImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class
+        );
+
+        Account account = new Account();
+        account.setStatus(ServiceStatus.Active.getKey());
+        account.setAccountType(AccountType.Clrn.getKey());
+        accountId = accountImdg.insert(account);
+
+        ClearingAccount clearingAccount = new ClearingAccount();
+        clearingAccount.setAccountId(accountId);
+        clearingAccount.setClearingAccountType("CAT");
+        clearingAccountId = clearingAccountImdg.insert(clearingAccount);
+
+        new TestObjectCreator(hazelcastServiceTest).createUserAdmin(1000L);
+    }
+
+    @PreDestroy
+    private void destroyTest() {
+        //clean test data
+        Account account = accountImdg.getSingleObjectByID(accountId);
+        if (account != null)
+            accountImdg.delete(account);
+        ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(clearingAccountId);
+        if (clearingAccount != null)
+            clearingAccountImdg.delete(clearingAccount);
+    }
+
+    @Test
+    void tradingClearingRegistryNew_moneyAccount_clearingAccount() {
+        setMockFuture(kafkaTemplate);
+        AccountSymbolsNewRequest accountSymbolsNewRequest = new AccountSymbolsNewRequest();
+        accountSymbolsNewRequest.setAccountId(accountId);
+        accountSymbolsNewRequest.setAccountSymbolValue("SYMBOL1");
+
+        AccountSymbols predictableAccountSymbols = new AccountSymbols();
+        predictableAccountSymbols.setAccountId(accountId);
+        predictableAccountSymbols.setAccountSymbolValue("SYMBOL1");
+
+        String jsonString = getJsonStringForNew(accountSymbolsNewRequest, 0L);
+
+        addRecordToKafka((MockConsumer) accountSymbolsService.getConsumer(),
+                Consts.DESTINATION_DEPO_ACCOUNT_SYMBOLS_NEW,
+                newRequestCnt,
+                0,
+                jsonString);
+
+        waitingSendAndCheckRecord(0L, mockProducer);
+
+        AccountSymbols resultNew = accountSymbolsImdg.getAllValues().iterator().next();
+        predictableAccountSymbols.setId(resultNew.getId());
+
+        ACCOUNT_SYMBOL_MATCHER.assertMatch(resultNew, predictableAccountSymbols);
+        accountSymbolsImdg.delete(resultNew); // cleanup test
+
+        newRequestCnt++;
+    }
+
+    @Test
+    void tradingClearingRegistryDelete() {
+        AccountSymbols existAccountSymbols = new AccountSymbols();
+        existAccountSymbols.setAccountId(accountId);
+        existAccountSymbols.setAccountSymbolValue("SYMBOL 2");
+        Long accountSymbolId = accountSymbolsImdg.insert(existAccountSymbols);
+
+        CommonDeleteRequest accountSymbolsDeleteRequest = new CommonDeleteRequest();
+        accountSymbolsDeleteRequest.setId(accountSymbolId);
+
+        String jsonString = getJsonStringForDelete(accountSymbolsDeleteRequest, 0);
+
+        //ACT
+        addRecordToKafka((MockConsumer) accountSymbolsService.getConsumer(),
+                Consts.DESTINATION_DEPO_ACCOUNT_SYMBOLS_DELETE,
+                PARTITION,
+                0,
+                jsonString);
+
+        //ASSERT
+        waitingSendAndCheckRecord(0L, mockProducer);
+
+        AccountSymbols resultUpdating = accountSymbolsImdg.getSingleObjectByID(accountSymbolId);
+        Assertions.assertNull(resultUpdating, "Должен был удалиться");
+    }
+
+}

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

@@ -1,17 +1,13 @@
 package ru.spcex.clearing.account.service;
 
 import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.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.boot.test.mock.mockito.SpyBean;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.account.Account;
@@ -25,7 +21,6 @@ import ru.spcex.clearing.account.config.validation.AccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.BankAccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.ValidationConfig;
 import ru.spcex.clearing.account.errors.AccountError;
-import ru.spcex.clearing.account.utils.MatcherFactory.Matcher;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
@@ -34,12 +29,13 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewReq
 import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountUpdateRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.test.MatcherFactory.Matcher;
 import ru.spcex.clearing.test.TestObjectCreator;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 
@@ -49,13 +45,14 @@ import java.util.concurrent.atomic.AtomicInteger;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
-import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
 import static ru.spcex.clearing.platform.messaging.service.Status.Error;
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
 import static ru.spcex.clearing.test.TestUtils.*;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.getCaptor;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
-        AccountService.class,
+        AccountHelper.class,
         BankAccountService.class,
         ValidationConfig.class,
         BankAccountValidationConfig.class,
@@ -97,15 +94,11 @@ public class BankAccountServiceTest {
 
     @Autowired
     @Qualifier("hazelcastServiceTest")
-    private HazelcastService hazelcastServiceTest;
+    private ImdgProvider hazelcastServiceTest;
 
     @Autowired
     private BankAccountService bankAccountService;
 
-    @Captor
-    private ArgumentCaptor<ProducerRecord> producerRecord;
-    @SpyBean
-    private MockProducer<String, Object> producer;
     @Autowired
     @Qualifier("mockProducer")
     protected Producer<String, Object> mockProducer;
@@ -133,8 +126,23 @@ 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();
@@ -159,6 +167,8 @@ 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);
 
@@ -167,10 +177,26 @@ 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);
@@ -180,12 +206,14 @@ public class BankAccountServiceTest {
         BankAccountNewRequest bankAccountNewRequest = getBankAccountNewRequest(predictableBankAccount);
 
         String errMsg;
+        //AccountValidationRule.RequiredFields
+        //WrongFieldValue
         bankAccountNewRequest.setCurrency(null);
-        errMsg = messageResolver.resolve(new EnumMessage(AccountError.RequiredFieldEmpty, "currency"));
+        errMsg = messageResolver.resolve(new EnumMessage(AccountError.RequiredFieldEmpty, "null, currency"));
         checkError(errMsg, bankAccountNewRequest);
 
         bankAccountNewRequest.setCurrency("TT0");
-        errMsg = messageResolver.resolve(new EnumMessage(AccountError.WrongFieldValue, "currency"));
+        errMsg = messageResolver.resolve(new EnumMessage(AccountError.DictionaryNotFound, "TT0, CurrencyCodeDictionary"));
         checkError(errMsg, bankAccountNewRequest);
 
         bankAccountNewRequest.setCurrency(currency);
@@ -204,33 +232,26 @@ public class BankAccountServiceTest {
         checkError(errMsg, bankAccountNewRequest);
 
         bankAccountNewRequest.setAccount(acc);
-        bankAccountNewRequest.setDestination(null);
-        errMsg = messageResolver.resolve(new EnumMessage(AccountError.RequiredFieldEmpty, "destination"));
+
+        //AccountValidationRule.CompanyPresent
+        //CompanyNotFound
+        bankAccountNewRequest.setCompanyId(999924535239L);
+        errMsg = messageResolver.resolve(new EnumMessage(AccountError.CompanyNotFound, bankAccountNewRequest.getCompanyId()+", companyId"));
         checkError(errMsg, bankAccountNewRequest);
 
-        bankAccountNewRequest.setDestination(destination);
-        bankAccountNewRequest.setCompanyId(null);
-        errMsg = messageResolver.resolve(new EnumMessage(AccountError.RequiredFieldEmpty, "companyId"));
-        checkError(errMsg, bankAccountNewRequest);
-        bankAccountNewRequest.setCompanyId(addresseeIdNew);
-        bankAccountNewRequest.setCompanyId(999924535239L);
-        errMsg = messageResolver.resolve(new EnumMessage(AccountError.CompanyNotFound, "companyId"));
-        checkError(errMsg, bankAccountNewRequest);
-        company.setWorkflowStatus(Status.Blocked.getKey());
-        companyImdg.insert(company);
         bankAccountNewRequest.setCompanyId(company.getId());
-        errMsg = messageResolver.resolve(new EnumMessage(AccountError.CompanyNotActive, "companyId"));
-        checkError(errMsg, bankAccountNewRequest);
-        company.setWorkflowStatus(Status.Active.getKey());
-        companyImdg.insert(company);
+
+        //AccountValidationRule.AccountIsNew
+        //AccountAlreadyExist
         Account existAccount = getTestAccount(accountId, acc);
         accountImdg.insert(existAccount);
-        errMsg = messageResolver.resolve(new EnumMessage(AccountError.AccountAlreadyExist, "account"));
+        errMsg = messageResolver.resolve(new EnumMessage(AccountError.AccountAlreadyExist, existAccount.getAccount()));
         checkError(errMsg, bankAccountNewRequest);
         accountImdg.delete(existAccount);
     }
 
     private void checkError(String errorMsg, BankAccountNewRequest bankAccountNewRequest) {
+        //ARRANGE
         int currentTime = countRun.getAndIncrement();
         long currentOffset = currentTime;
         BaseRequest<Object> predictableBaseRequest = new BaseRequest<>();
@@ -243,17 +264,41 @@ public class BankAccountServiceTest {
         predictableBaseRequest.setRequestPayload(requestInfoUpdate);
 
         String jsonString = getJsonStringForNew(bankAccountNewRequest, ID);
+
+        //ACT
         addRecordToKafka((MockConsumer) bankAccountService.getConsumer(), TOPIC_ACCOUNT_NEW, PARTITION, currentOffset, jsonString);
-        verify(producer, timeout(30_000L).times(currentTime))
+
+        ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(mockProducer);
+        //waiting for kafka producer send message (finale event)
+        verify(mockProducer, timeout(30_000L).times(currentTime))
                 .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);
 
@@ -284,7 +329,11 @@ public class BankAccountServiceTest {
         bankAccountUpdateRequest.setAccount(predictableUpdateBankAccount.getAccount());
 
         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());
@@ -296,8 +345,15 @@ public class BankAccountServiceTest {
         ACCOUNT_MATCHER.assertMatch(accountResult, predictableAccount);
     }
 
+    /**
+     * {@link BankAccountService#bankAccountBlock(BaseRequest)}
+     * Тест проверяет удаление сущности {@link BankAccount} в Hazelcast при передаче из Apache Kafka.
+     * Входной запрос {@link CommonDeleteRequest}:
+     * {@link CommonDeleteRequest#id} - Идентификатор записи
+     */
     @Test
-    void bankAccountDelete() {
+    void bankAccountBlock() {
+        //ARRANGE
         BankAccount bankAccountExists = getBankAccount();
         bankAccountImdg.insert(bankAccountExists);
         Account account = new Account();
@@ -308,11 +364,15 @@ 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);
 
-        BankAccount bankAccount = bankAccountImdg.getSingleObjectByID(ID);
-        Assertions.assertNull(bankAccount);
+        Account bankAccount = accountImdg.getSingleObjectByID(accountId);
+        assertEquals(bankAccount.getStatus(), WorkflowStatus.Blocked.getKey());
     }
 
     private Company getTestCompany() {

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

@@ -1,16 +1,13 @@
 package ru.spcex.clearing.account.service;
 
 import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.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.boot.test.mock.mockito.SpyBean;
+import org.springframework.kafka.core.KafkaTemplate;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.account.Account;
@@ -24,25 +21,31 @@ import ru.spcex.clearing.account.config.BeanConfiguration;
 import ru.spcex.clearing.account.config.validation.AccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.ClearingAccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.ValidationConfig;
-import ru.spcex.clearing.account.utils.MatcherFactory;
+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.ClearingAccountNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.ClearingAccountUpdateRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01Request;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
+import ru.spcex.clearing.test.MatcherFactory;
 import ru.spcex.clearing.test.TestObjectCreator;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;
 
 import javax.annotation.PostConstruct;
+import java.util.Collections;
 import java.util.Map;
 
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.verify;
-import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
 import static ru.spcex.clearing.test.TestUtils.*;
+import static ru.spcex.clearing.test.config.ImdgTestConfig.currentID;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.setMockFuture;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
@@ -50,8 +53,9 @@ import static ru.spcex.clearing.test.TestUtils.*;
         ValidationConfig.class,
         ClearingAccountValidationConfig.class,
         AccountValidationConfig.class,
-        AccountService.class,
+        AccountHelper.class,
         ClearingAccountService.class,
+        SDFProcessService.class,
         ImdgTestConfig.class,
         KafkaTestConfig.class})
 class ClearingAccountServiceTest {
@@ -69,16 +73,16 @@ class ClearingAccountServiceTest {
 
     @Autowired
     @Qualifier("hazelcastServiceTest")
-    private HazelcastService hazelcastServiceTest;
+    private ImdgProvider hazelcastServiceTest;
 
-    @Captor
-    private ArgumentCaptor<ProducerRecord> producerRecord;
-    @SpyBean
-    private MockProducer<String, Object> producer;
     @Autowired
     @Qualifier("mockProducer")
     protected Producer<String, Object> mockProducer;
 
+    @Autowired
+    @Qualifier("kafkaTestTemplate")
+    protected KafkaTemplate<String, Object> kafkaTemplate;
+
     private Imdg<ClearingAccount> clearingAccountImdg;
     private Imdg<Account> accountImdg;
     private Imdg<Company> companyImdg;
@@ -159,8 +163,7 @@ class ClearingAccountServiceTest {
                 0,
                 jsonString);
 
-        verify(producer, timeout(30_000L).times(2))
-                .send(producerRecord.capture());
+        waitingSendAndCheckRecord(0L, mockProducer);
 
         Account predictableAccount = new Account();
         predictableAccount.setAccount(ACCOUNT_VALUE);
@@ -223,4 +226,65 @@ class ClearingAccountServiceTest {
 
         ACCOUNT_MATCHER.assertMatch(accountResult, predictableAccount);
     }
+
+    @Test
+    void makeSdfErrorText() {
+        Assertions.assertEquals("013", clearingAccountService.makeSdfErrorText(AccountError.CompanyNotFound, SDFProcessService.SDF_STATUS_ERROR_COMPANY_NOT_FOUND));
+        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();
+        Long secondID = currentID.getAndIncrement();
+        AccountSdfRequestPart accountSdfRequestPart = new AccountSdfRequestPart();
+        accountSdfRequestPart.setSdfId(firstID);
+        accountSdfRequestPart.setAccount(ACCOUNT_VALUE);
+        accountSdfRequestPart.setCompanyId(firstID);
+        AccountSdf01Request accountSdf01Request = new AccountSdf01Request();
+        accountSdf01Request.setGroupingSdf01Id(firstID);
+        accountSdf01Request.setAccounts(Collections.singletonList(accountSdfRequestPart));
+
+        String jsonString = getJsonStringForNew(accountSdf01Request, 0L);
+
+        Account predictableAccount = new Account();
+        predictableAccount.setAccount(ACCOUNT_VALUE);
+        predictableAccount.setCompanyId(firstID);
+        predictableAccount.setAccountType(AccountType.Clrn.getKey());
+        predictableAccount.setStatus(ServiceStatus.Active.getKey());
+        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());
+        predictableClearingAccount.setAccountId(accountResult.getId());
+        predictableClearingAccount.setId(resultClearingAccountNew.getId());
+        predictableAccount.setId(accountResult.getId());
+        ACCOUNT_MATCHER.assertMatch(accountResult, predictableAccount);
+        CLEARING_ACCOUNT_MATCHER.assertMatch(resultClearingAccountNew, predictableClearingAccount);
+        accountImdg.delete(accountResult);
+    }
 }

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

@@ -24,12 +24,13 @@ import ru.spcex.clearing.account.config.BeanConfiguration;
 import ru.spcex.clearing.account.config.validation.ClientCodeValidationConfig;
 import ru.spcex.clearing.account.config.validation.TradingClearingRegistryValidationConfig;
 import ru.spcex.clearing.account.config.validation.ValidationConfig;
-import ru.spcex.clearing.account.utils.MatcherFactory;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.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.test.MatcherFactory;
 import ru.spcex.clearing.test.TestObjectCreator;
 import ru.spcex.clearing.test.TestUtils;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
@@ -79,10 +80,15 @@ class ClientCodeServiceTest {
 
     private Imdg<ClientCode> clientCodeImdg;
 
+
+    // ****************************-*******************
+
     @PostConstruct
     private void init() {
         hazelcastServiceTest.waitAvailable();
         clientCodeImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClientCode, ClientCode.class);
+
+        // Словари для теста, применяются в ValidationConfig
         putToDictionary(IMDGDistributedNames.Map_WorkflowStatusDictionary, new WorkflowStatusDictionary(), "ACTV");
         putToDictionary(IMDGDistributedNames.Map_CompanySymbolDictionary, new CompanySymbolDictionary(), "CLRC");
         putToDictionary(IMDGDistributedNames.Map_CorporationSoleTypeDictionary, new CorporationSoleTypeDictionary(), "GDIR");
@@ -123,7 +129,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());
@@ -135,7 +141,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());
@@ -170,8 +176,14 @@ 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);
@@ -185,9 +197,16 @@ 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);
         ClientCode resultNew = clientCodeImdg.getFirstObjectBySQL(String.format("code = '%s'", ccCode));
         predictableClientCode.setId(resultNew.getId());
@@ -195,8 +214,14 @@ class ClientCodeServiceTest {
         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);
@@ -210,9 +235,16 @@ 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);
         ClientCode resultNew = clientCodeImdg.getFirstObjectBySQL(String.format("code = '%s'", ccCode));
         predictableClientCode.setId(resultNew.getId());
@@ -221,8 +253,15 @@ 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);
@@ -239,9 +278,13 @@ 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());
@@ -249,8 +292,14 @@ 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 clientCodeUpdate() {
+        //ARRANGE
         ClientCode existsClientCode = new ClientCode();
         existsClientCode.setId(ID);
         existsClientCode.setCompanyId(COMPANY_ID);
@@ -278,9 +327,13 @@ 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);
@@ -289,12 +342,19 @@ 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);
@@ -305,14 +365,56 @@ class ClientCodeServiceTest {
         CommonDeleteRequest clientCodeDeleteRequest = new CommonDeleteRequest();
         clientCodeDeleteRequest.setId(ID);
 
-        Assertions.assertNotNull(clientCodeImdg.getSingleObjectByID(ID));
+        Assertions.assertNotNull(clientCodeImdg.getSingleObjectByID(ID)); // verify test data
+
+        //ACT
         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);
-        Assertions.assertNull(resultUpdate);
+        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/DepoAccountServiceTest.java

@@ -1,16 +1,11 @@
 package ru.spcex.clearing.account.service;
 
 import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.Producer;
-import org.apache.kafka.clients.producer.ProducerRecord;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.boot.test.mock.mockito.SpyBean;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.account.Account;
@@ -24,25 +19,22 @@ import ru.spcex.clearing.account.config.BeanConfiguration;
 import ru.spcex.clearing.account.config.validation.AccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.DepoAccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.ValidationConfig;
-import ru.spcex.clearing.account.utils.MatcherFactory;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.DepoAccountNewRequest;
+import ru.spcex.clearing.test.MatcherFactory;
 import ru.spcex.clearing.test.TestObjectCreator;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.imdg.api.ImdgProvider;
 
 import javax.annotation.PostConstruct;
 import java.util.Map;
 
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.verify;
-import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
-import static ru.spcex.clearing.test.TestUtils.addRecordToKafka;
-import static ru.spcex.clearing.test.TestUtils.getJsonStringForNew;
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.test.TestUtils.*;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
@@ -50,7 +42,7 @@ import static ru.spcex.clearing.test.TestUtils.getJsonStringForNew;
         ValidationConfig.class,
         DepoAccountValidationConfig.class,
         AccountValidationConfig.class,
-        AccountService.class,
+        AccountHelper.class,
         DepoAccountService.class,
         ImdgTestConfig.class,
         KafkaTestConfig.class})
@@ -69,12 +61,8 @@ class DepoAccountServiceTest {
 
     @Autowired
     @Qualifier("hazelcastServiceTest")
-    private HazelcastService hazelcastServiceTest;
+    private ImdgProvider hazelcastServiceTest;
 
-    @Captor
-    private ArgumentCaptor<ProducerRecord> producerRecord;
-    @SpyBean
-    private MockProducer<String, Object> producer;
     @Autowired
     @Qualifier("mockProducer")
     protected Producer<String, Object> mockProducer;
@@ -159,8 +147,7 @@ class DepoAccountServiceTest {
                 0,
                 jsonString);
 
-        verify(producer, timeout(30_000L).times(2))
-                .send(producerRecord.capture());
+        waitingSendAndCheckRecord(0L, mockProducer);
 
         Account predictableAccount = new Account();
         predictableAccount.setAccount(ACCOUNT_VALUE);

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

@@ -1,17 +1,13 @@
 package ru.spcex.clearing.account.service;
 
 import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.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.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.boot.test.mock.mockito.SpyBean;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.account.Account;
@@ -24,26 +20,23 @@ import ru.spcex.clearing.account.config.BeanConfiguration;
 import ru.spcex.clearing.account.config.validation.AccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.InformationAccountValidationConfig;
 import ru.spcex.clearing.account.config.validation.ValidationConfig;
-import ru.spcex.clearing.account.utils.MatcherFactory;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.InformationAccountNewRequest;
+import ru.spcex.clearing.test.MatcherFactory;
 import ru.spcex.clearing.test.TestObjectCreator;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.clearing.util.security.UserRoleVerification;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
 
 import javax.annotation.PostConstruct;
 import java.util.Map;
 
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.verify;
-import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
-import static ru.spcex.clearing.test.TestUtils.addRecordToKafka;
-import static ru.spcex.clearing.test.TestUtils.getJsonStringForNew;
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.test.TestUtils.*;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
@@ -51,7 +44,7 @@ import static ru.spcex.clearing.test.TestUtils.getJsonStringForNew;
         ValidationConfig.class,
         InformationAccountValidationConfig.class,
         AccountValidationConfig.class,
-        AccountService.class,
+        AccountHelper.class,
         InformationAccountService.class,
         ImdgTestConfig.class,
         KafkaTestConfig.class})
@@ -69,12 +62,8 @@ class InformationAccountServiceTest {
 
     @Autowired
     @Qualifier("hazelcastServiceTest")
-    private HazelcastService hazelcastServiceTest;
+    private ImdgProvider hazelcastServiceTest;
 
-    @Captor
-    private ArgumentCaptor<ProducerRecord> producerRecord;
-    @SpyBean
-    private MockProducer<String, Object> producer;
     @Autowired
     @Qualifier("mockProducer")
     protected Producer<String, Object> mockProducer;
@@ -96,6 +85,7 @@ class InformationAccountServiceTest {
         accountImdg = hazelcastServiceTest.getImdg(
                 IMDGDistributedNames.Map_Account, Account.class
         );
+        clearImdg(accountImdg);
 
         companyImdg = hazelcastServiceTest.getImdg(
                 IMDGDistributedNames.Map_Company, Company.class
@@ -143,6 +133,7 @@ class InformationAccountServiceTest {
     void accountInformationNew() {
         InformationAccountNewRequest InformationAccountNewRequest = new InformationAccountNewRequest();
         InformationAccountNewRequest.setCompanyId(companyId);
+        InformationAccountNewRequest.setAccount(account);
 
         String jsonString = getJsonStringForNew(InformationAccountNewRequest, 0L);
 
@@ -151,8 +142,8 @@ class InformationAccountServiceTest {
                 PARTITION,
                 0,
                 jsonString);
-        verify(producer, timeout(30_000L).times(2))
-                .send(producerRecord.capture());
+
+        waitingSendAndCheckRecord(0L, mockProducer);
 
         Account predictableAccount = new Account();
         predictableAccount.setAccountType(AccountType.Info.getKey());
@@ -168,7 +159,7 @@ class InformationAccountServiceTest {
         InformationAccount resultInfoAccountNew = informationAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", resultAccountNew.getId()));
 
         predictableAccount.setId(resultAccountNew.getId());
-        predictableAccount.setAccount(informationAccountService.generateInfoAccount(resultInfoAccountNew.getId()));
+        predictableAccount.setAccount(account);
         predictableInfoAccount.setAccountId(resultAccountNew.getId());
         predictableInfoAccount.setId(resultInfoAccountNew.getId());
 
@@ -179,7 +170,6 @@ class InformationAccountServiceTest {
         accountImdg.delete(resultAccountNew);
     }
 
-    @Autowired ImdgProvider imdgProvider;
     @Test
     void accountIncrementSequence() {
         Imdg<InformationAccount> accountInfoImdg = hazelcastServiceTest.getImdg( IMDGDistributedNames.Map_InformationAccount, InformationAccount.class );
@@ -197,8 +187,9 @@ class InformationAccountServiceTest {
             accountInfo.setCompanyId(account.getCompanyId());
             accountInfoImdg.insert(accountInfo);
         }
+        UserRoleVerification userRoleVerification = Mockito.mock(UserRoleVerification.class);
         InformationAccountService infoAccSvc=new InformationAccountService(null,null,null,
-                null, imdgProvider, null, null, null, null);
+                null, userRoleVerification, hazelcastServiceTest, null, null, null, null);
         Long n = infoAccSvc.accountNextId();
         Assertions.assertEquals(13L, n);
         n = infoAccSvc.accountNextId();

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

@@ -0,0 +1,106 @@
+package ru.spcex.clearing.account.service;
+
+import org.apache.kafka.clients.producer.MockProducer;
+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.boot.test.mock.mockito.SpyBean;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.ClearingAccount;
+import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.company.relation.Relation;
+import ru.clearing.platform.dictionary.AccountTypeDictionary;
+import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary;
+import ru.spcex.clearing.account.config.BeanConfiguration;
+import ru.spcex.clearing.account.config.validation.ValidationConfig;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.test.TestObjectCreator;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.AccountStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+import javax.annotation.PostConstruct;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        BeanConfiguration.class,
+        ValidationConfig.class,
+        SDFProcessService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class})
+class SDFProcessServiceTest {
+    @Autowired
+    SDFProcessService sdfProcessService;
+
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider hazelcastServiceTest;
+
+    @Captor
+    private ArgumentCaptor<ProducerRecord> producerRecord;
+    @SpyBean
+    private MockProducer<String, Object> producer;
+    @Autowired
+    @Qualifier("mockProducer")
+    protected Producer<String, Object> mockProducer;
+
+    private Imdg<ClearingAccount> clearingAccountImdg;
+    private Imdg<Account> accountImdg;
+    private Imdg<Company> companyImdg;
+    private Imdg<ClearingAccountTypeDictionary> clearingAccountTypeDictionaryImdg;
+    private Imdg<AccountTypeDictionary> accountTypeDictionaryImdg;
+    private Imdg<ClearingMemberCategory> clearingMemberCategoryImdg;
+    private Imdg<Relation> relationImdg;
+
+
+    @PostConstruct
+    private void init() {
+        hazelcastServiceTest.waitAvailable();
+        clearingAccountImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class
+        );
+        accountImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_Account, Account.class
+        );
+
+        companyImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_Company, Company.class
+        );
+        accountTypeDictionaryImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.class
+        );
+        clearingAccountTypeDictionaryImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_ClearingAccountTypeDictionary, ClearingAccountTypeDictionary.class
+        );
+        clearingMemberCategoryImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class
+        );
+        relationImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_Relation, Relation.class
+        );
+
+
+        new TestObjectCreator(hazelcastServiceTest).createUserAdmin(1000L);
+    }
+
+    @Test
+    void parseSdf52Status() {
+        Assertions.assertEquals(AccountStatus.BLOCKED, sdfProcessService.parseSdf52Status(0L));
+        Assertions.assertEquals(AccountStatus.ACTIVE, sdfProcessService.parseSdf52Status(1L));
+        Assertions.assertEquals(AccountStatus.ACTIVE, sdfProcessService.parseSdf52Status(3L));
+        Assertions.assertEquals(AccountStatus.CLOSE, sdfProcessService.parseSdf52Status(2L));
+        Assertions.assertEquals(null, sdfProcessService.parseSdf52Status(4705211956118233163L));
+        Assertions.assertEquals(null, sdfProcessService.parseSdf52Status(null));
+    }
+}

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

@@ -1,17 +1,13 @@
 package ru.spcex.clearing.account.service;
 
 import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.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.boot.test.mock.mockito.SpyBean;
+import org.springframework.kafka.core.KafkaTemplate;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.account.Account;
@@ -19,31 +15,30 @@ 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.CompanySymbols;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.clearing.platform.dictionary.ServiceStatusDictionary;
 import ru.spcex.clearing.account.config.BeanConfiguration;
 import ru.spcex.clearing.account.config.validation.TradingClearingRegistryValidationConfig;
 import ru.spcex.clearing.account.config.validation.ValidationConfig;
-import ru.spcex.clearing.account.utils.MatcherFactory;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest;
+import ru.spcex.clearing.test.MatcherFactory;
 import ru.spcex.clearing.test.TestObjectCreator;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
-import ru.spcex.platform.enumeration.ServiceStatus;
-import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose;
-import ru.spcex.platform.enumeration.TradingClearingRegistryType;
-import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.imdg.api.ImdgProvider;
 
 import javax.annotation.PostConstruct;
 
-import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
 import static ru.spcex.clearing.test.TestUtils.*;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.setMockFuture;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
@@ -64,18 +59,19 @@ class TradingClearingRegistryServiceTest {
     TradingClearingRegistryService tradingClearingRegistryService;
     @Autowired
     @Qualifier("hazelcastServiceTest")
-    private HazelcastService hazelcastServiceTest;
+    private ImdgProvider hazelcastServiceTest;
 
-    @Captor
-    private ArgumentCaptor<ProducerRecord> producerRecord;
-    @SpyBean
-    private MockProducer<String, Object> producer;
     @Autowired
     @Qualifier("mockProducer")
     protected Producer<String, Object> mockProducer;
 
+    @Autowired
+    @Qualifier("kafkaTestTemplate")
+    protected KafkaTemplate<String, Object> kafkaTemplate;
+
     private Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
     private Imdg<Company> companyImdg;
+    private Imdg<CompanySymbols> companySymbolsImdg;
     private Imdg<ServiceStatusDictionary> serviceStatusDictionaryImdg;
 
     private Imdg<ClearingAccount> clearingAccountImdg;
@@ -103,6 +99,9 @@ class TradingClearingRegistryServiceTest {
         companyImdg = hazelcastServiceTest.getImdg(
                 IMDGDistributedNames.Map_Company, Company.class
         );
+        companySymbolsImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class
+        );
         serviceStatusDictionaryImdg = hazelcastServiceTest.getImdg(
                 IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class
         );
@@ -129,8 +128,14 @@ class TradingClearingRegistryServiceTest {
         company.setClearingCode("77");
         companyImdg.insert(company);
 
+        CompanySymbols companySymbols = new CompanySymbols();
+        companySymbols.setCompanyId(companyId);
+        companySymbols.setCompanySymbol(CompanySymbol.CLRC.getKey());
+        companySymbolsImdg.insert(companySymbols);
+
         Account account = new Account();
         account.setStatus(ServiceStatus.Active.getKey());
+        account.setAccountType(AccountType.Clrn.getKey());
         accountId = accountImdg.insert(account);
 
         account2Id = accountImdg.insert(account);
@@ -154,15 +159,17 @@ class TradingClearingRegistryServiceTest {
 
     @Test
     void tradingClearingRegistryNew_moneyAccount_clearingAccount() {
+        setMockFuture(kafkaTemplate);
         TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest();
         tradingClearingRegistryNewRequest.setCompanyId(companyId);
         tradingClearingRegistryNewRequest.setMoneyAccountId(accountId);
+        tradingClearingRegistryNewRequest.setTradingClearingRegistryType(TradingClearingRegistryType.Owner_A.getKey());
 
         TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry();
         predictableTradingClearingRegistry.setCompanyId(companyId);
-        predictableTradingClearingRegistry.setCode("0077MAT");
+        predictableTradingClearingRegistry.setCode("0077MAT00001");
         predictableTradingClearingRegistry.setMoneyAccountId(accountId);
-        predictableTradingClearingRegistry.setTradingClearingRegistryType("CAT");
+        predictableTradingClearingRegistry.setTradingClearingRegistryType(TradingClearingRegistryType.Owner_A.getKey());
         predictableTradingClearingRegistry.setTradingClearingRegistryPurpose(TradingClearingRegistryPurpose.M.getKey());
         predictableTradingClearingRegistry.setStatus(ServiceStatus.Active.getKey());
 
@@ -178,7 +185,6 @@ class TradingClearingRegistryServiceTest {
 
         TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next();
         predictableTradingClearingRegistry.setId(resultNew.getId());
-        predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId());
         predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated());
         predictableTradingClearingRegistry.setCreated(resultNew.getCreated());
 
@@ -190,13 +196,16 @@ class TradingClearingRegistryServiceTest {
 
     @Test
     void tradingClearingRegistryNew_moneyAccount_informationAccount() {
+        setMockFuture(kafkaTemplate);
+        clearImdg(tradingClearingRegistryImdg);
         TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest();
         tradingClearingRegistryNewRequest.setCompanyId(companyId);
         tradingClearingRegistryNewRequest.setMoneyAccountId(account2Id);
+        tradingClearingRegistryNewRequest.setTradingClearingRegistryType(TradingClearingRegistryType.Owner_A.getKey());
 
         TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry();
         predictableTradingClearingRegistry.setCompanyId(companyId);
-        predictableTradingClearingRegistry.setCode("0077MAT");
+        predictableTradingClearingRegistry.setCode("0077MAT00001");
         predictableTradingClearingRegistry.setMoneyAccountId(account2Id);
         predictableTradingClearingRegistry.setTradingClearingRegistryType(TradingClearingRegistryType.Owner_A.getKey());
         predictableTradingClearingRegistry.setTradingClearingRegistryPurpose(TradingClearingRegistryPurpose.M.getKey());
@@ -210,11 +219,10 @@ class TradingClearingRegistryServiceTest {
                 0,
                 jsonString);
 
-        waitingSendAndCheckRecord(0L, producer, producerRecord);
+        waitingSendAndCheckRecord(0L, mockProducer);
 
         TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next();
         predictableTradingClearingRegistry.setId(resultNew.getId());
-        predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId());
         predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated());
         predictableTradingClearingRegistry.setCreated(resultNew.getCreated());
 
@@ -227,6 +235,8 @@ class TradingClearingRegistryServiceTest {
 
     @Test
     void tradingClearingRegistryNew_depoAccount() {
+        setMockFuture(kafkaTemplate);
+        clearImdg(tradingClearingRegistryImdg);
         TradingClearingRegistryNewRequest tradingClearingRegistryNewRequest = new TradingClearingRegistryNewRequest();
         tradingClearingRegistryNewRequest.setCompanyId(companyId);
         tradingClearingRegistryNewRequest.setMoneyAccountId(accountId);
@@ -234,7 +244,7 @@ class TradingClearingRegistryServiceTest {
 
         TradingClearingRegistry predictableTradingClearingRegistry = new TradingClearingRegistry();
         predictableTradingClearingRegistry.setCompanyId(companyId);
-        predictableTradingClearingRegistry.setCode("0077CDAT");
+        predictableTradingClearingRegistry.setCode("0077CDATT00001");
         predictableTradingClearingRegistry.setMoneyAccountId(accountId);
         predictableTradingClearingRegistry.setDepoAccountId(account2Id);
         predictableTradingClearingRegistry.setTradingClearingRegistryType("DAT");
@@ -249,14 +259,12 @@ class TradingClearingRegistryServiceTest {
                 0,
                 jsonString);
 
-        waitingSendAndCheckRecord(0L, producer, producerRecord);
+        waitingSendAndCheckRecord(0L, mockProducer);
 
         TradingClearingRegistry resultNew = tradingClearingRegistryImdg.getAllValues().iterator().next();
         predictableTradingClearingRegistry.setId(resultNew.getId());
-        predictableTradingClearingRegistry.setCode(predictableTradingClearingRegistry.getCode() + resultNew.getId());
         predictableTradingClearingRegistry.setUpdated(resultNew.getUpdated());
         predictableTradingClearingRegistry.setCreated(resultNew.getCreated());
-        predictableTradingClearingRegistry.setCompanyId(123L);
 
         TRADING_CLEARING_REGISTRY_MATCHER.assertMatch(resultNew, predictableTradingClearingRegistry);
         tradingClearingRegistryImdg.delete(resultNew);
@@ -275,12 +283,16 @@ class TradingClearingRegistryServiceTest {
         tradingClearingRegistryUpdateRequest.setId(registryId);
 
         String jsonString = getJsonStringForUpdate(tradingClearingRegistryUpdateRequest, 0);
+
+        //ACT
         addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
                 Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE,
                 PARTITION,
                 0,
                 jsonString);
-        waitingSendAndCheckRecord(0L, producer, producerRecord);
+
+        //ASSERT
+        waitingSendAndCheckRecord(0L, mockProducer);
 
         TradingClearingRegistry resultUpdating = tradingClearingRegistryImdg.getSingleObjectByID(registryId);
         existTradingClearingRegistry.setUpdated(resultUpdating.getUpdated());
@@ -299,12 +311,16 @@ class TradingClearingRegistryServiceTest {
         tradingClearingRegistryDeleteRequest.setId(registryId);
 
         String jsonString = getJsonStringForDelete(tradingClearingRegistryDeleteRequest, 0);
+
+        //ACT
         addRecordToKafka((MockConsumer) tradingClearingRegistryService.getConsumer(),
                 Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK,
                 PARTITION,
                 0,
                 jsonString);
-        waitingSendAndCheckRecord(0L, producer, producerRecord);
+
+        //ASSERT
+        waitingSendAndCheckRecord(0L, mockProducer);
 
         TradingClearingRegistry resultUpdating = tradingClearingRegistryImdg.getSingleObjectByID(registryId);
         existTradingClearingRegistry.setUpdated(resultUpdating.getUpdated());
@@ -325,8 +341,8 @@ class TradingClearingRegistryServiceTest {
                 "000000105", TradingClearingRegistryPurpose.C, "ER", 100012L
         ));
 
-        Assertions.assertEquals("0105MAT100012", tradingClearingRegistryService.makeCode(
-                "000000105", TradingClearingRegistryPurpose.M, "ER", 100012L
+        Assertions.assertEquals("0105MAT00012", tradingClearingRegistryService.makeCode(
+                "000000105", TradingClearingRegistryPurpose.M, "A", 100012L
         ));
     }
 

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

@@ -1,61 +0,0 @@
-package ru.spcex.clearing.account.utils;
-
-import com.hazelcast.core.IMap;
-import com.hazelcast.map.listener.EntryAddedListener;
-import com.hazelcast.map.listener.EntryRemovedListener;
-import com.hazelcast.map.listener.EntryUpdatedListener;
-
-import java.util.Timer;
-import java.util.TimerTask;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-public class ImapEvent<T> {
-    private final IMap<Long, T> iMap;
-    private final String listenerAdding;
-    private final String listenerUpdating;
-    private final String listenerRemoving;
-    private final AtomicBoolean checkEventHappened = new AtomicBoolean(false);
-
-    public ImapEvent(IMap<Long, T> iMap) {
-        this.iMap = iMap;
-        listenerAdding = iMap.addEntryListener((EntryAddedListener<Long, T>) entryEvent -> {
-            synchronized (checkEventHappened) {
-                checkEventHappened.set(true);
-                checkEventHappened.notify();
-            }
-        }, false);
-        listenerUpdating = iMap.addEntryListener((EntryUpdatedListener<Long, T>) entryEvent -> {
-            synchronized (checkEventHappened) {
-                checkEventHappened.set(true);
-                checkEventHappened.notify();
-            }
-        }, false);
-        listenerRemoving = iMap.addEntryListener((EntryRemovedListener<Long, T>) entryEvent -> {
-            synchronized (checkEventHappened) {
-                checkEventHappened.set(true);
-                checkEventHappened.notify();
-            }
-        }, false);
-    }
-
-    public void waitWhenHappened() throws InterruptedException {
-        Timer timer = new Timer(true);
-        timer.scheduleAtFixedRate(new TimerTask() {
-            boolean secondRan;
-
-            @Override
-            public void run() {
-                checkEventHappened.set(secondRan);
-                secondRan = true;
-            }
-        }, 0, 30 * 1000);
-        synchronized (checkEventHappened) {
-            while (!checkEventHappened.get()) {
-                checkEventHappened.wait(100);
-            }
-        }
-        iMap.removeEntryListener(listenerAdding);
-        iMap.removeEntryListener(listenerUpdating);
-        iMap.removeEntryListener(listenerRemoving);
-    }
-}

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

@@ -1,33 +0,0 @@
-package ru.spcex.clearing.account.utils;
-
-import java.util.Arrays;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class MatcherFactory {
-
-    public static <T> Matcher<T> usingIgnoringFieldsComparator(String... fieldsToIgnore) {
-        return new Matcher<>(fieldsToIgnore);
-    }
-
-    public static class Matcher<T> {
-        private final String[] fieldsToIgnore;
-
-        private Matcher(String... fieldsToIgnore) {
-            this.fieldsToIgnore = fieldsToIgnore;
-        }
-
-        public void assertMatch(T actual, T expected) {
-            assertThat(actual).usingRecursiveComparison().ignoringFields(fieldsToIgnore).isEqualTo(expected);
-        }
-
-        @SafeVarargs
-        public final void assertMatch(Iterable<T> actual, T... expected) {
-            assertMatch(actual, Arrays.asList(expected));
-        }
-
-        public void assertMatch(Iterable<T> actual, Iterable<T> expected) {
-            assertThat(actual).usingRecursiveFieldByFieldElementComparatorIgnoringFields(fieldsToIgnore).isEqualTo(expected);
-        }
-    }
-}

clearing-parent/backend-api/pom.xml

@@ -195,6 +195,19 @@
                                         </fileMapper>
                                     </fileMappers>
                                 </transformationSet>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>data_initial.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/data.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>data_initial.sql</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
                             </transformationSets>
                         </configuration>
                     </execution>

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

@@ -26,6 +26,7 @@ public class BackendApiApplication extends SpringBootServletInitializer {
     @Override
     protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
         setKeycloakConfigFile();
+        //        springApplicationBuilder.initializers(DfaConfig.get().getLoggingInitializer());
         return builder.sources(BackendApiApplication.class);
     }
 
@@ -34,6 +35,9 @@ 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

@@ -1,5 +1,7 @@
 package ru.spcex.clearing.backendapi.config;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.annotation.Bean;
@@ -11,6 +13,8 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
 
 @Configuration
 public class BackEndApiImdgConfig {
+    Logger log = LoggerFactory.getLogger(getClass());
+
     @Bean(name = "taskExecutorHazelcastClientInitializer")
     public ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer() {
         return createThreadPoolTaskExecutor(1, true);
@@ -21,6 +25,16 @@ public class BackEndApiImdgConfig {
         return createThreadPoolTaskExecutor(1, false);
     }
 
+    @Bean(name = "taskExecutorHazelcastClientInitializerHist")
+    public ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializerHist() {
+        return createThreadPoolTaskExecutor(1, true);
+    }
+
+    @Bean(name = "taskExecutorIdGeneratorAwaiterHist")
+    public ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiterHist() {
+        return createThreadPoolTaskExecutor(1, false);
+    }
+
     @Autowired
     @Bean
     public ImdgProvider imdgProvider(
@@ -28,9 +42,33 @@ public class BackEndApiImdgConfig {
             @Qualifier("taskExecutorIdGeneratorAwaiter") ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter,
             BackendApiSettings clientSetting
     ) {
-        return new HazelcastService(taskExecutorHazelcastClientInitializer,
+        if (clientSetting.getHazelcast() == null || clientSetting.getHazelcast().getClusterMembers() == null) {
+            log.warn("Property \"backend-api.hazelcast.cluster-members\" not set!");
+            throw new IllegalArgumentException("Property \"backend-api.hazelcast.cluster-members\" not set");
+        }
+        ImdgProvider imdg = new HazelcastService(taskExecutorHazelcastClientInitializer,
                 taskExecutorIdGeneratorAwaiter,
                 clientSetting.getHazelcast());
+// todo корректное ожидание готовности        imdg.waitAvailable();
+        return imdg;
+    }
+
+    @Autowired
+    @Bean
+    public ImdgProvider imdgProviderHist(
+            @Qualifier("taskExecutorHazelcastClientInitializerHist") ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer,
+            @Qualifier("taskExecutorIdGeneratorAwaiterHist") ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter,
+            BackendApiSettings clientSetting
+    ) {
+        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();
+        return imdg;
     }
 
 

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

@@ -0,0 +1,177 @@
+package ru.spcex.clearing.backendapi.config;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.HistorySubscription;
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.*;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+
+import java.util.LinkedList;
+import java.util.List;
+
+@Configuration
+public class HistoryConfig {
+
+    private final ImdgPredicateBuilder pb;
+
+    @Autowired
+    public HistoryConfig(ImdgProvider imdgProvider) {
+        this.pb = imdgProvider.getImdg(
+                IMDGDistributedNames.Map_SearchMoneyBalanceRegister,
+                SpcexObjectBase.class
+        ).predicateBuilder();
+    }
+
+    @Bean
+    public List<HistorySubscription> histSubscriptions() {
+        List<HistorySubscription> hst = new LinkedList<>();
+        hst.add(executionDeposit());
+        hst.add(executionFond());
+        hst.add(depoBalanceRegister());
+        hst.add(moneyBalanceRegister());
+        hst.add(admittedLiabilitiesRegister());
+        hst.add(coveredLiabilitiesRegister());
+        hst.add(moneyPaymentInstructionRegister());
+        hst.add(depoPaymentInstructionRegister());
+        hst.add(excludeLiabilitiesRegister());
+        hst.add(liabilitiesRegister());
+        hst.add(executionRegister());
+        return hst;
+    }
+
+    private HistorySubscription moneyBalanceRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("money-balance-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchMoneyBalanceRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_MoneyBalanceRegister);
+        sbscr.setConditions(List.of(
+                new CreatedFromCondition(pb),
+                new CreatedToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription depoBalanceRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("depo-balance-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchDepoBalanceRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_DepoBalanceRegister);
+        sbscr.setConditions(List.of(
+                new CreatedFromCondition(pb),
+                new CreatedToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription depoPaymentInstructionRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("depo-payment-instruction-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchDepoPaymentInstructionRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_DepoPaymentInstructionRegister);
+        sbscr.setConditions(List.of(
+                new CreatedFromCondition(pb),
+                new CreatedToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription excludeLiabilitiesRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("exclude-liabilities-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchExcludeLiabilitiesRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister);
+        sbscr.setConditions(List.of(
+                new CreatedFromCondition(pb),
+                new CreatedToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription liabilitiesRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("liabilities-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchLiabilitiesRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_LiabilitiesRegister);
+        sbscr.setConditions(List.of(
+                new CreatedFromCondition(pb),
+                new CreatedToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription admittedLiabilitiesRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("admitted-liabilities-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchAdmittedLiabilitiesRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister);
+        sbscr.setConditions(List.of(
+                new ClearingDateFromCondition(pb),
+                new ClearingDateToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription executionRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("execution-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchExecutionRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_ExecutionRegister);
+        sbscr.setConditions(List.of(
+                new ClearingDateFromCondition(pb),
+                new ClearingDateToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription moneyPaymentInstructionRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("money-payment-instruction-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchMoneyPaymentInstructionRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister);
+        sbscr.setConditions(List.of(
+                new ClearingDateFromCondition(pb),
+                new ClearingDateToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription coveredLiabilitiesRegister() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("covered-liabilities-registers");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchCoveredLiabilitiesRegister);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_CoveredLiabilitiesRegister);
+        sbscr.setConditions(List.of(
+                new ClearingDateFromCondition(pb),
+                new ClearingDateToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription executionDeposit() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("execution-deposits");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchExecutionDeposit);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_ExecutionDeposit);
+        sbscr.setConditions(List.of(
+                new TradingDateFromCondition(pb),
+                new TradingDateToCondition(pb)
+        ));
+        return sbscr;
+    }
+
+    private HistorySubscription executionFond() {
+        HistorySubscription sbscr = new HistorySubscription();
+        sbscr.setDestination("execution-fonds");
+        sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchExecutionFond);
+        sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_ExecutionFond);
+        sbscr.setConditions(List.of(
+                new TradingDateFromCondition(pb),
+                new TradingDateToCondition(pb)
+        ));
+        return sbscr;
+    }
+}

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

@@ -1,35 +1,26 @@
 package ru.spcex.clearing.backendapi.config;
 
-import org.apache.kafka.clients.admin.AdminClient;
-import org.apache.kafka.clients.admin.AdminClientConfig;
-import org.apache.kafka.clients.admin.NewTopic;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.consumer.MockConsumer;
 import org.apache.kafka.clients.consumer.OffsetResetStrategy;
 import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.Producer;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Profile;
+import org.springframework.context.annotation.Scope;
 import org.springframework.kafka.core.KafkaTemplate;
 import org.springframework.kafka.core.ProducerFactory;
 import ru.spcex.clearing.backendapi.config.element.BackendApiSettings;
 import ru.spcex.clearing.platform.messaging.config.KafkaConsumerFactory;
 import ru.spcex.clearing.platform.messaging.config.KafkaProducerFactory;
 import ru.spcex.clearing.platform.messaging.config.element.KafkaProducerSettings;
-import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.platform.imdg.api.ImdgId;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 
-import javax.annotation.PostConstruct;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Properties;
-import java.util.concurrent.ExecutionException;
-
 @Configuration
 public class KafkaConfig {
 
@@ -40,8 +31,6 @@ public class KafkaConfig {
         return KafkaProducerFactory.producer(settings.getKafkaProducer());
     }
 
-
-
     @Bean
     public ProducerFactory<String, Object> pf(BackendApiSettings settings) {
         KafkaProducerSettings kafkaSettings = settings.getKafkaProducer();
@@ -73,6 +62,7 @@ public class KafkaConfig {
 
     @Profile("!kafkaDisabled")
     @Autowired
+    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
     @Bean
     public Consumer<String, Object> createConsumer(BackendApiSettings settings) {
         return KafkaConsumerFactory.consumer(settings.getKafkaConsumer());

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

@@ -22,6 +22,7 @@ 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/config/element/BackendApiSettings.java

@@ -13,6 +13,7 @@ import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams;
 @ConfigurationProperties("backend-api")
 public class BackendApiSettings {
     private HazelcastClientParams hazelcast;
+    private HazelcastClientParams hazelcastSearch;
     private KafkaProducerSettings kafkaProducer;
     private KafkaConsumerSettings kafkaConsumer;
     private SecuritySettings security;
@@ -57,4 +58,12 @@ public class BackendApiSettings {
     public void setSecurity(SecuritySettings security) {
         this.security = security;
     }
+
+    public HazelcastClientParams getHazelcastSearch() {
+        return hazelcastSearch;
+    }
+
+    public void setHazelcastSearch(HazelcastClientParams hazelcastSearch) {
+        this.hazelcastSearch = hazelcastSearch;
+    }
 }

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

@@ -4,6 +4,7 @@ import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
 import ru.spcex.clearing.backendapi.service.IOperator;
 
+import java.util.Objects;
 import java.util.concurrent.ExecutionException;
 
 public abstract class AbstractQueueController {
@@ -21,6 +22,9 @@ 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/AccountSymbolsController.java

@@ -0,0 +1,71 @@
+package ru.spcex.clearing.backendapi.controller.queue.account;
+
+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.account.AccountSymbols;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.request.cud.account.AccountSymbolsNewAction;
+import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
+import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
+import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+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("/accounting/depo-accounts-symbols")
+public class AccountSymbolsController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public AccountSymbolsController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all accounts-symbols.")
+    @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_AccountSymbols, AccountSymbols.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+
+
+    @ApiOperation(value = "create AccountSymbols.")
+    @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 AccountSymbolsNewAction accountNewAction) throws ExecutionException, InterruptedException {
+        return processRequest(Consts.DESTINATION_DEPO_ACCOUNT_SYMBOLS_NEW, accountNewAction);
+    }
+
+    @ApiOperation(value = "delete AccountSymbols.")
+    @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_DEPO_ACCOUNT_SYMBOLS_DELETE, deleteAction);
+    }
+
+}

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

@@ -1,28 +1,40 @@
 package ru.spcex.clearing.backendapi.controller.queue.account;
 
 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.RequestBody;
 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.account.InformationAccount;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.request.cud.account.AccountInformationNewAction;
+import ru.spcex.clearing.backendapi.controller.request.cud.account.BankAccountNewAction;
+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("/accounting/information-accounts")
-public class InformationAccountController {
+public class InformationAccountController extends AbstractQueueController {
     private final IStateLoader stateLoader;
 
     @Autowired
-    public InformationAccountController(IStateLoader stateLoader) {
+    public InformationAccountController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
         this.stateLoader = stateLoader;
     }
 
@@ -37,4 +49,15 @@ public class InformationAccountController {
         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

@@ -1,22 +1,28 @@
 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.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.*;
 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.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("/company-role-sets")
@@ -41,4 +47,26 @@ public class CompanyRoleSetController extends AbstractQueueController {
         response.fromEntity(all);
         return response;
     }
+
+    @ApiOperation(value = "create CompanyRoleSet.")
+    @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)
+    @ResponseBody
+    public CudResponse create(
+            @ApiParam(value = "Значения полей нового объекта.", required = true)
+            @RequestBody CompanyRoleSetNewAction companyRoleSetNewAction) throws ExecutionException, InterruptedException {
+        return processRequest(Consts.DESTINATION_COMPANY_ROLE_SET_NEW, companyRoleSetNewAction);
+    }
+
+    @ApiOperation(value = "delete CompanyRoleSet.")
+    @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_COMPANY_ROLE_SET_DELETE, deleteAction);
+    }
+
 }

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

@@ -14,7 +14,11 @@ import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllRespo
 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;
 
@@ -22,11 +26,16 @@ import java.util.Map;
 @RequestMapping("/execution-deposits")
 public class ExecutionDepositController extends AbstractQueueController {
     private final IStateLoader stateLoader;
+    private final ImdgPredicateBuilder imdgPredicateBuilder;
 
     @Autowired
-    public ExecutionDepositController(IOperator operator, IStateLoader stateLoader) {
+    public ExecutionDepositController(IOperator operator, IStateLoader stateLoader,
+                                      ImdgProvider imdgProvider) {
         super(operator);
         this.stateLoader = stateLoader;
+        this.imdgPredicateBuilder = imdgProvider
+                .getImdg(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class)
+                .predicateBuilder();
     }
 
     @ApiOperation(value = "get all ExecutionDeposits.")
@@ -34,9 +43,11 @@ public class ExecutionDepositController extends AbstractQueueController {
     @RequestMapping(method = RequestMethod.GET)
     @ResponseBody
     public CommonGetAllResponse getAll() {
+        ImdgPredicate imdgPredicate = imdgPredicateBuilder.greatEqual("firstLegSettlementDate", LocalDate.now());
         Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
                 IMDGDistributedNames.Map_ExecutionDeposit,
-                ExecutionDeposit.class);
+                ExecutionDeposit.class,
+                imdgPredicate);
         CommonGetAllResponse response = new CommonGetAllResponse();
         response.fromEntity(all);
         return response;

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

@@ -14,7 +14,11 @@ import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllRespo
 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;
 
@@ -22,11 +26,17 @@ import java.util.Map;
 @RequestMapping("/execution-fonds")
 public class ExecutionFondController extends AbstractQueueController {
     private final IStateLoader stateLoader;
+    private final ImdgPredicateBuilder imdgPredicateBuilder;
 
     @Autowired
-    public ExecutionFondController(IOperator operator, IStateLoader stateLoader) {
+    public ExecutionFondController(IOperator operator,
+                                   IStateLoader stateLoader,
+                                   ImdgProvider imdgProvider) {
         super(operator);
         this.stateLoader = stateLoader;
+        this.imdgPredicateBuilder = imdgProvider
+                .getImdg(IMDGDistributedNames.Map_ExecutionFond, ExecutionFond.class)
+                .predicateBuilder();
     }
 
     @ApiOperation(value = "get all ExecutionFond.")
@@ -34,9 +44,11 @@ public class ExecutionFondController extends AbstractQueueController {
     @RequestMapping(method = RequestMethod.GET)
     @ResponseBody
     public CommonGetAllResponse getAll() {
+        ImdgPredicate imdgPredicate = imdgPredicateBuilder.greatEqual("settlementDate", LocalDate.now());
         Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
                 IMDGDistributedNames.Map_ExecutionFond,
-                ExecutionFond.class);
+                ExecutionFond.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

@@ -0,0 +1,95 @@
+package ru.spcex.clearing.backendapi.controller.queue.history;
+
+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.format.annotation.DateTimeFormat;
+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.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.ConditionProvider;
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.HistorySubscription;
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.errors.ActionValidationException;
+import ru.spcex.clearing.backendapi.errors.BackEndError;
+import ru.spcex.clearing.backendapi.meta.GetResponseFactory;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+
+import java.time.LocalDate;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+
+@Controller
+@RequestMapping("/history")
+public class HistController {
+    private final GetResponseFactory responseFactory;
+    private final IStateLoader stateLoader;
+    private final ConditionProvider conditionProvider;
+
+    @Autowired
+    public HistController(GetResponseFactory responseFactory,
+                          IStateLoader stateLoader,
+                          ConditionProvider conditionProvider) {
+        this.responseFactory = responseFactory;
+        this.stateLoader = stateLoader;
+        this.conditionProvider = conditionProvider;
+    }
+
+    @ApiOperation(value = "Get history")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getHistory(
+            @ApiParam(value = "destination сущности по которой запрашивается история", example = "money-balance-registers", required = true)
+            @RequestParam("destination")
+            String destination,
+            @ApiParam(value = "Начальная точка поиска по дате", example = "2023-01-15")
+            @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
+            @RequestParam(name = "from", required = false)
+            LocalDate from,
+            @ApiParam(value = "Конечная точка поиска по дате", example = "2023-01-15")
+            @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
+            @RequestParam(name = "to", required = false)
+            LocalDate to
+    ) {
+        if (to == null && from == null) {
+            throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError, "from/to url params both empty"));
+        }
+
+        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)"));
+        }
+
+        HistoryRequest req = new HistoryRequest();
+        req.setTable(destination);
+        req.setFrom(from);
+        req.setTo(to);
+
+        HistorySubscription[] subscr = new HistorySubscription[1];
+        ImdgPredicate[] prdct = new ImdgPredicate[1];
+        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]
+        );
+
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(searchRes);
+        return response;
+    }
+}

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

@@ -0,0 +1,72 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.clearing.backendapi.errors.ActionValidationException;
+import ru.spcex.clearing.backendapi.errors.BackEndError;
+import ru.spcex.clearing.backendapi.meta.GetResponseFactory;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.utils.collection.Pair;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@Component
+public class ConditionProvider {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final GetResponseFactory responseFactory;
+    private final ImdgPredicateBuilder pb;
+
+    private final Map<String, HistorySubscription> subscriptions;
+
+    @Autowired
+    public ConditionProvider(GetResponseFactory responseFactory, ImdgProvider imdgProvider,
+                             List<HistorySubscription> subscriptions) {
+        this.responseFactory = responseFactory;
+        this.subscriptions = new HashMap<>();
+        Imdg<SpcexObjectBase> imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class);
+        this.pb = imdg.predicateBuilder();
+        subscriptions.forEach(s -> this.subscriptions.put(s.getDestination(), s));
+    }
+
+    public Pair<HistorySubscription, ImdgPredicate> conditionForRequest(HistoryRequest req) {
+        String destination = req.getTable();
+        HistorySubscription subscription = subscriptions.get(destination);
+        if (subscription == null) {
+            throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError,
+                    "destination " + "'" + destination + "' not supported (subscription info not found)"));
+        }
+
+        List<ImdgPredicate> predicates = subscription
+                .getConditions()
+                .stream()
+                .map(c -> c.condition(req))
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .toList();
+
+        ImdgPredicate result;
+        if (predicates.size() == 0) {
+            //add boundary conditions?
+            log.warn("destination '{}' zero predicates found", destination);
+            result = pb.alwaysTrue();
+        } else if (predicates.size() == 1) {
+            result = predicates.iterator().next();
+        } else {
+            result = pb.and(predicates.toArray(new ImdgPredicate[0]));
+        }
+
+        return new Pair<>(subscription, result);
+    }
+}

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

@@ -0,0 +1,46 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition;
+
+import java.util.Collections;
+import java.util.List;
+
+public class HistorySubscription {
+    private String destination;
+
+    private List<IHistoryCondition> conditions;
+    private String searchProxyMapName;
+    private String fullHistoryMapName;
+    //class
+
+
+    public List<IHistoryCondition> getConditions() {
+        return conditions != null ? conditions : Collections.emptyList();
+    }
+
+    public void setConditions(List<IHistoryCondition> conditions) {
+        this.conditions = conditions;
+    }
+
+    public String getSearchProxyMapName() {
+        return searchProxyMapName;
+    }
+
+    public void setSearchProxyMapName(String searchProxyMapName) {
+        this.searchProxyMapName = searchProxyMapName;
+    }
+
+    public String getFullHistoryMapName() {
+        return fullHistoryMapName;
+    }
+
+    public void setFullHistoryMapName(String fullHistoryMapName) {
+        this.fullHistoryMapName = fullHistoryMapName;
+    }
+
+    public String getDestination() {
+        return destination;
+    }
+
+    public void setDestination(String destination) {
+        this.destination = destination;
+    }
+}

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

@@ -0,0 +1,15 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition;
+
+
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+
+import java.util.Optional;
+
+public interface IHistoryCondition {
+    Optional<ImdgPredicate> condition(HistoryRequest req);
+
+    default Optional<ImdgPredicate> of(ImdgPredicate predicate) {
+        return Optional.of(predicate);
+    }
+}

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

@@ -0,0 +1,25 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific;
+
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition;
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+
+import java.util.Optional;
+
+public class ClearingDateFromCondition implements IHistoryCondition {
+
+    private final ImdgPredicateBuilder pb;
+
+    public ClearingDateFromCondition(ImdgPredicateBuilder pb) {
+        this.pb = pb;
+    }
+
+    @Override
+    public Optional<ImdgPredicate> condition(HistoryRequest req) {
+        if (req.getFrom() != null) {
+            return Optional.ofNullable(pb.greatEqual("clearingDate", req.getFrom()));
+        }
+        return Optional.empty();
+    }
+}

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

@@ -0,0 +1,25 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific;
+
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition;
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+
+import java.util.Optional;
+
+public class ClearingDateToCondition implements IHistoryCondition {
+
+    private final ImdgPredicateBuilder pb;
+
+    public ClearingDateToCondition(ImdgPredicateBuilder pb) {
+        this.pb = pb;
+    }
+
+    @Override
+    public Optional<ImdgPredicate> condition(HistoryRequest req) {
+        if (req.getTo() != null) {
+            return Optional.ofNullable(pb.lessEqual("clearingDate", req.getTo()));
+        }
+        return Optional.empty();
+    }
+}

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

@@ -0,0 +1,26 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific;
+
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition;
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.utils.time.TimeUtil;
+
+import java.util.Optional;
+
+public class CreatedFromCondition implements IHistoryCondition {
+
+    private final ImdgPredicateBuilder pb;
+
+    public CreatedFromCondition(ImdgPredicateBuilder pb) {
+        this.pb = pb;
+    }
+
+    @Override
+    public Optional<ImdgPredicate> condition(HistoryRequest req) {
+        if (req.getFrom() != null) {
+            return Optional.of(pb.greatEqual("created", TimeUtil.localDateToInstant(req.getFrom())));
+        }
+        return Optional.empty();
+    }
+}

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

@@ -0,0 +1,26 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific;
+
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition;
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.utils.time.TimeUtil;
+
+import java.util.Optional;
+
+public class CreatedToCondition implements IHistoryCondition {
+
+    private final ImdgPredicateBuilder pb;
+
+    public CreatedToCondition(ImdgPredicateBuilder pb) {
+        this.pb = pb;
+    }
+
+    @Override
+    public Optional<ImdgPredicate> condition(HistoryRequest req) {
+        if (req.getTo() != null) {
+            return Optional.of(pb.lessEqual("created", TimeUtil.localDateToInstant(req.getTo())));
+        }
+        return Optional.empty();
+    }
+}

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

@@ -0,0 +1,25 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific;
+
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition;
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+
+import java.util.Optional;
+
+public class TradingDateFromCondition implements IHistoryCondition {
+
+    private final ImdgPredicateBuilder pb;
+
+    public TradingDateFromCondition(ImdgPredicateBuilder pb) {
+        this.pb = pb;
+    }
+
+    @Override
+    public Optional<ImdgPredicate> condition(HistoryRequest req) {
+        if (req.getFrom() != null) {
+            return Optional.ofNullable(pb.greatEqual("tradingDate", req.getFrom()));
+        }
+        return Optional.empty();
+    }
+}

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

@@ -0,0 +1,25 @@
+package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific;
+
+import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition;
+import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+
+import java.util.Optional;
+
+public class TradingDateToCondition implements IHistoryCondition {
+
+    private final ImdgPredicateBuilder pb;
+
+    public TradingDateToCondition(ImdgPredicateBuilder pb) {
+        this.pb = pb;
+    }
+
+    @Override
+    public Optional<ImdgPredicate> condition(HistoryRequest req) {
+        if (req.getTo() != null) {
+            return Optional.ofNullable(pb.lessEqual("tradingDate", req.getTo()));
+        }
+        return Optional.empty();
+    }
+}

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

@@ -7,13 +7,10 @@ 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.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.*;
 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.RSplitDepositActionNew;
+import ru.spcex.clearing.backendapi.controller.request.cud.registry.*;
 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;
@@ -57,4 +54,57 @@ public class RegistryController extends AbstractQueueController {
             @RequestBody RSplitDepositActionNew rSplitDepositActionNew) throws ExecutionException, InterruptedException {
         return processRequest(Consts.REGISTRY_SPLIT_DEPOSIT_ACTION, rSplitDepositActionNew);
     }
+
+    @ApiOperation(value = "Отметить средства на возврат депозита")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/returnDeposit/{id}", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse returnDepositAction(
+            @ApiParam(value = "Идентификатор изменяемого объекта.", required = true, example = "1234")
+            @PathVariable("id") Long id,
+            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+            @RequestBody ReturnDepositActionNew returnDepositAction) throws ExecutionException, InterruptedException {
+        returnDepositAction.setId(id);
+        return processRequest(Consts.REGISTRY_RETURN_DEPOSIT_ACTION, returnDepositAction);
+    }
+
+    @ApiOperation(value = "Отметить средства на возврат депозита")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/identificationFunds/{id}", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse identificationFundsAction(
+            @ApiParam(value = "Идентификатор изменяемого объекта.", required = true, example = "1234")
+            @PathVariable("id") Long id,
+            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+            @RequestBody IdentificationFundsActionNew identificationFundsActionNew) throws ExecutionException, InterruptedException {
+        identificationFundsActionNew.setId(id);
+        return processRequest(Consts.REGISTRY_IDENTIFICATION_FUNDS, identificationFundsActionNew);
+    }
+
+    @ApiOperation(value = "Изменение даты возврата депозита")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/changeRefundDate/{groupId}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse changeRefundDate(
+            @ApiParam(value = "Идентификатор группы связанных регистров.", required = true, example = "1234")
+            @PathVariable("groupId") Long groupId,
+            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+            @RequestBody ChangeRefundDateActionNew returnDepositAction) throws ExecutionException, InterruptedException {
+        returnDepositAction.setGroupId(groupId);
+        return processRequest(Consts.REGISTRY_CHANGE_REFUND_DATE_ACTION, returnDepositAction);
+    }
+
+    @ApiOperation(value = "Установить отметку о получение выписки")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/changeStatusExtract/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse changeStatusExtract(
+            @ApiParam(value = "Идентификатор регистра.", required = true, example = "1234")
+            @PathVariable("id") Long id,
+            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+            @RequestBody ChangeStatusExtractActionNew changeStatusExtractAction) throws ExecutionException, InterruptedException {
+        changeStatusExtractAction.setId(id);
+        return processRequest(Consts.REGISTRY_CHANGE_STATUS_EXTRACT_ACTION, changeStatusExtractAction);
+    }
+
 }

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

@@ -4,6 +4,8 @@ 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.HttpStatus;
 import org.springframework.http.MediaType;
@@ -29,6 +31,7 @@ import ru.spcex.platform.enumeration.Task;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 
 import java.util.Collection;
@@ -38,6 +41,7 @@ import java.util.concurrent.ExecutionException;
 @Controller
 @RequestMapping("/launchers")
 public class LauncherController extends AbstractQueueController {
+    protected final Logger log = LoggerFactory.getLogger(getClass());
     private final IStateLoader stateLoader;
     private final Imdg<User> userImdg;
     private final Imdg<AbstractDictionary> taskDictionary;
@@ -82,6 +86,8 @@ 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);
     }
 
@@ -98,9 +104,9 @@ public class LauncherController extends AbstractQueueController {
         if (taskEnum == null) {
             throw new NotFound404Exception("task dictionary element with code '" + launcherNew.getTask() + "'");
         }
-        if (!Task.startOfClearing.getKey().equals(taskEnum.getCode())) {
-            throw new IllegalStateException(String.format("Task %s not support request with body", taskEnum.getCode()));
-        }
+        if (!IEnumKey.contains(taskEnum.getCode(), Task.startOfClearing, Task.dbfExport_OUTV)) {
+            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/securities/SecurityController.java

@@ -11,6 +11,7 @@ import org.springframework.web.bind.annotation.ResponseBody;
 import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
 import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
 import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
+import ru.clearing.classes.statics.data.security.Security;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
 import ru.spcex.clearing.backendapi.service.IStateLoader;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
@@ -19,6 +20,9 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;
 
+/**
+ * SecurityController и MoneyMarketSecurityController разные контроллеры, не путать.
+ */
 @Controller
 @RequestMapping("/securities")
 public class SecurityController {

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

@@ -90,6 +90,10 @@ 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,6 +58,8 @@ 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

@@ -0,0 +1,71 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.account;
+
+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.account.InformationAccountNewRequest;
+
+public class AccountInformationNewAction implements IAction<InformationAccountNewRequest> {
+
+    @ApiModelProperty(value = "Наименование компании", example = "1200")
+    @JsonProperty
+    private Long companyId;
+    @ApiModelProperty(value = "Номер счета", example = "A30101111111111111776")
+    @JsonProperty
+    private String account;
+    @ApiModelProperty(value = "Наименование статуса", example = "ACTV")
+    @JsonProperty
+    private String status;
+    @ApiModelProperty(value = "Наименование типа счета", example = "INFO")
+    @JsonProperty
+    private String accountType;
+
+    @Override
+    public InformationAccountNewRequest toRequest() {
+        var req = new InformationAccountNewRequest();
+        req.setCompanyId(this.companyId);
+        req.setAccount(this.account);
+        req.setStatus(this.status);
+        req.setAccountType(this.accountType);
+        return req;
+    }
+
+    @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 getAccount() {
+        return account;
+    }
+
+    public void setAccount(String account) {
+        this.account = account;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public String getAccountType() {
+        return accountType;
+    }
+
+    public void setAccountType(String accountType) {
+        this.accountType = accountType;
+    }
+}

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

@@ -0,0 +1,47 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.account;
+
+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.account.AccountSymbolsNewRequest;
+
+public class AccountSymbolsNewAction implements IAction<AccountSymbolsNewRequest> {
+
+    @ApiModelProperty(value = "Номер счета", example = "1200")
+    @JsonProperty
+    private Long accountId;
+    @ApiModelProperty(value = "Значение реквизита", example = "ABCD")
+    @JsonProperty
+    private String accountSymbolValue;
+
+    @Override
+    public AccountSymbolsNewRequest toRequest() {
+        var req = new AccountSymbolsNewRequest();
+        req.setAccountId(this.accountId);
+        req.setAccountSymbolValue(this.accountSymbolValue);
+        return req;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.NEW;
+    }
+
+    public Long getAccountId() {
+        return accountId;
+    }
+
+    public void setAccountId(Long accountId) {
+        this.accountId = accountId;
+    }
+
+    public String getAccountSymbolValue() {
+        return accountSymbolValue;
+    }
+
+    public void setAccountSymbolValue(String accountSymbolValue) {
+        this.accountSymbolValue = accountSymbolValue;
+    }
+}

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

@@ -0,0 +1,59 @@
+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.CompanyRoleSetNewRequest;
+
+public class CompanyRoleSetNewAction implements IAction<CompanyRoleSetNewRequest> {
+    @ApiModelProperty(value = "Наименование компании", example = "1234")
+    @JsonProperty
+    Long companyId;
+    @ApiModelProperty(value = "Код роли компании", example = "ABCD")
+    @JsonProperty
+    String companyRole;
+    @ApiModelProperty(value = "Код статуса", example = "ACTV")
+    @JsonProperty
+    String workflowStatus;
+
+    @Override
+    public CompanyRoleSetNewRequest toRequest() {
+        CompanyRoleSetNewRequest request = new CompanyRoleSetNewRequest();
+        request.setCompanyId(this.companyId);
+        request.setCompanyRole(this.companyRole);
+        request.setWorkflowStatus(this.workflowStatus);
+        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 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/history/HistoryRequest.java

@@ -0,0 +1,51 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.history;
+
+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.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
+import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
+
+import java.time.LocalDate;
+
+public class HistoryRequest {
+
+    @ApiModelProperty(value = "Таблица для поиска", example = "1200")
+    @JsonProperty
+    private String table;
+    @ApiModelProperty(value = "Начальный точка поиска по дате", example = "2022-12-25")
+    @JsonProperty
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    private LocalDate from;
+    @ApiModelProperty(value = "Конечная точка поиска по дате ", example = "2022-12-25")
+    @JsonProperty
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    private LocalDate to;
+
+    public String getTable() {
+        return table;
+    }
+
+    public void setTable(String table) {
+        this.table = table;
+    }
+
+    public LocalDate getFrom() {
+        return from;
+    }
+
+    public void setFrom(LocalDate from) {
+        this.from = from;
+    }
+
+    public LocalDate getTo() {
+        return to;
+    }
+
+    public void setTo(LocalDate to) {
+        this.to = to;
+    }
+}

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

@@ -0,0 +1,71 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.registry;
+
+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.registry.RegistryChangeRefundDateRequest;
+import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
+import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class ChangeRefundDateActionNew implements IAction<RegistryChangeRefundDateRequest> {
+
+    @JsonIgnore
+    public Long groupId;
+    @JsonProperty
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    public LocalDate refundDate;
+
+    @Override
+    public RegistryChangeRefundDateRequest toRequest() {
+        var req = new RegistryChangeRefundDateRequest();
+        req.setGroupId(groupId);
+        req.setRefundDate(refundDate);
+        return req;
+    }
+
+    @Override
+    public Collection<EnumMessage> validate() {
+        List<EnumMessage> errors = new ArrayList<>();
+        if (groupId == null) {
+            errors.add(new EnumMessage(BackEndError.ValidationError, "url parameter 'groupId'"));
+        }
+        if (refundDate == null) {
+            errors.add(new EnumMessage(BackEndError.ValidationError, "refundDate"));
+        }
+        return errors;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.UPDATE;
+    }
+
+    public Long getGroupId() {
+        return groupId;
+    }
+
+    public void setGroupId(Long groupId) {
+        this.groupId = groupId;
+    }
+
+    public LocalDate getRefundDate() {
+        return refundDate;
+    }
+
+    public void setRefundDate(LocalDate refundDate) {
+        this.refundDate = refundDate;
+    }
+}

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

@@ -0,0 +1,82 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.registry;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+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.RegistryChangeStatusExtractRequest;
+
+import java.math.BigDecimal;
+
+public class ChangeStatusExtractActionNew implements IAction<RegistryChangeStatusExtractRequest> {
+
+    @JsonIgnore
+    public Long id;
+    @JsonProperty
+    public String shortName;
+    @JsonProperty
+    public String contract;
+    @JsonProperty
+    public BigDecimal balance;
+    @JsonProperty
+    public String registryStatus;
+
+    @Override
+    public RegistryChangeStatusExtractRequest toRequest() {
+        var req = new RegistryChangeStatusExtractRequest();
+        req.setId(id);
+        req.setShortName(shortName);
+        req.setContract(contract);
+        req.setBalance(balance);
+        req.setRegistryStatus(registryStatus);
+        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 getShortName() {
+        return shortName;
+    }
+
+    public void setShortName(String shortName) {
+        this.shortName = shortName;
+    }
+
+    public String getContract() {
+        return contract;
+    }
+
+    public void setContract(String contract) {
+        this.contract = contract;
+    }
+
+    public BigDecimal getBalance() {
+        return balance;
+    }
+
+    public void setBalance(BigDecimal balance) {
+        this.balance = balance;
+    }
+
+    public String getRegistryStatus() {
+        return registryStatus;
+    }
+
+    public void setRegistryStatus(String registryStatus) {
+        this.registryStatus = registryStatus;
+    }
+}

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

@@ -0,0 +1,89 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.registry;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+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.registry.IdentificationFundsRequest;
+import ru.spcex.platform.classes.base.interfaces.WithId;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class IdentificationFundsActionNew implements IAction<IdentificationFundsRequest>, WithId {
+
+    @JsonIgnore
+    public Long id;
+    @ApiModelProperty(value = "Сумма", example = "1600.20")
+    @JsonProperty
+    public BigDecimal balance;
+    @ApiModelProperty(value = "Торгово-клиринговый регистр", example = "1234")
+    @JsonProperty
+    public Long tradingClearingRegistryId;
+    @ApiModelProperty(value = "Идентификатор компании", example = "1234")
+    @JsonProperty
+    public Long companyId;
+
+    @Override
+    public IdentificationFundsRequest toRequest() {
+        var req = new IdentificationFundsRequest();
+        req.setId(id);
+        req.setBalance(balance);
+        req.setTradingClearingRegistryId(tradingClearingRegistryId);
+        req.setCompanyId(companyId);
+        return req;
+    }
+
+    @Override
+    public Collection<EnumMessage> validate() {
+        List<EnumMessage> errors = new ArrayList<>();
+        if (id == null) {
+            errors.add(new EnumMessage(BackEndError.ValidationError, "url parameter 'id'"));
+        }
+        return errors;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.NEW;
+    }
+
+    @Override
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public BigDecimal getBalance() {
+        return balance;
+    }
+
+    public void setBalance(BigDecimal balance) {
+        this.balance = balance;
+    }
+
+    public Long getTradingClearingRegistryId() {
+        return tradingClearingRegistryId;
+    }
+
+    public void setTradingClearingRegistryId(Long tradingClearingRegistryId) {
+        this.tradingClearingRegistryId = tradingClearingRegistryId;
+    }
+
+    public Long getCompanyId() {
+        return companyId;
+    }
+
+    public void setCompanyId(Long companyId) {
+        this.companyId = companyId;
+    }
+}

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

@@ -13,6 +13,10 @@ public class NotificationUpdateAction implements IAction<NotificationUpdateReque
     @ApiModelProperty(value = "Наименование статуса сообщения", example = "ACTV")
     @JsonProperty
     public String notificationStatus;
+    @ApiModelProperty(value = "Наименование отправителя (не исопльзуется)", example = "1234")
+    @JsonProperty(required = false)
+    @Deprecated
+    public Long senderId;
 
     @Override
     public NotificationUpdateRequest toRequest() {
@@ -43,4 +47,12 @@ public class NotificationUpdateAction implements IAction<NotificationUpdateReque
     public void setNotificationStatus(String notificationStatus) {
         this.notificationStatus = notificationStatus;
     }
+
+    public Long getSenderId() {
+        return senderId;
+    }
+
+    public void setSenderId(Long senderId) {
+        this.senderId = senderId;
+    }
 }

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

@@ -36,6 +36,9 @@ public class RSplitDepositActionNew implements IAction<RegistrySplitDepositActio
     @ApiModelProperty(value = "Договор для разделения", example = "ABCD")
     @JsonProperty
     public String contract;
+    @ApiModelProperty(value = "Направление", example = "OUT")
+    @JsonProperty
+    public String direction;
 
 
     @Override
@@ -45,6 +48,7 @@ public class RSplitDepositActionNew implements IAction<RegistrySplitDepositActio
         req.setOutboundAmount(this.outboundAmount);
         req.setRefundDate(this.refundDate);
         req.setContract(this.contract);
+        req.setDirection(this.direction);
         return req;
     }
 
@@ -85,4 +89,12 @@ public class RSplitDepositActionNew implements IAction<RegistrySplitDepositActio
     public void setContract(String contract) {
         this.contract = contract;
     }
+
+    public String getDirection() {
+        return direction;
+    }
+
+    public void setDirection(String direction) {
+        this.direction = direction;
+    }
 }

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

@@ -0,0 +1,68 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.registry;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+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.registry.RegistryReturnDepositRequest;
+import ru.spcex.platform.classes.base.interfaces.WithId;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class ReturnDepositActionNew implements IAction<RegistryReturnDepositRequest>, WithId {
+
+    @JsonIgnore
+    public Long id;
+    @ApiModelProperty(value = "Сумма", example = "1600.20")
+    @JsonProperty
+    public BigDecimal balance;
+
+    @Override
+    public RegistryReturnDepositRequest toRequest() {
+        var req = new RegistryReturnDepositRequest();
+        req.setId(id);
+        req.setBalance(balance);
+        return req;
+    }
+
+    @Override
+    public Collection<EnumMessage> validate() {
+        List<EnumMessage> errors = new ArrayList<>();
+        if (id == null) {
+            errors.add(new EnumMessage(BackEndError.ValidationError, "url parameter 'id'"));
+        }
+        if (balance == null) {
+            errors.add(new EnumMessage(BackEndError.ValidationError, "balance"));
+        }
+        return errors;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.NEW;
+    }
+
+    @Override
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public BigDecimal getBalance() {
+        return balance;
+    }
+
+    public void setBalance(BigDecimal balance) {
+        this.balance = balance;
+    }
+}

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

@@ -9,6 +9,7 @@ import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 
+import java.math.BigDecimal;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -35,6 +36,34 @@ public class LauncherNew implements IAction<Object> {
     @JsonProperty
     private Long sessionId;
 
+    @ApiModelProperty(value = "Текущий баланс (свободно)", example = "12.22")
+    @JsonProperty
+    private BigDecimal balance;
+    @ApiModelProperty(value = "Текущий баланс (всего)", example = "12.22")
+    @JsonProperty
+    private BigDecimal fullBalance;
+    @ApiModelProperty(value = "Наименование инструмента/валюты", example = "SPB")
+    @JsonProperty
+    private String securitySymbol;
+    @ApiModelProperty(value = "Сумма отправителя", example = "12.22")
+    @JsonProperty
+    private BigDecimal creditLeg_amount;
+    @ApiModelProperty(value = "Назначение платежа", example = "text")
+    @JsonProperty
+    private String paymentPurpose;
+    @ApiModelProperty(value = "Участник отправитель", example = "1000")
+    @JsonProperty
+    private Long senderId;
+    @ApiModelProperty(value = "Наименование счета отправителя", example = "1000")
+    @JsonProperty
+    private Long creditLeg_accountId;
+    @ApiModelProperty(value = "Участник получатель", example = "1000")
+    @JsonProperty
+    private Long addresseeId;
+    @ApiModelProperty(value = "Наименование счета получателя", example = "1000")
+    @JsonProperty
+    private Long debitLeg_accountId;
+
     @Override
     public Object toRequest() {
         LauncherCommandRequest taskRunnerCommandRequest = new LauncherCommandRequest();
@@ -45,6 +74,15 @@ public class LauncherNew implements IAction<Object> {
         taskRunnerCommandRequest.setSection(section);
         taskRunnerCommandRequest.setSessionType(sessionType);
         taskRunnerCommandRequest.setSessionId(sessionId);
+        taskRunnerCommandRequest.setBalance(balance);
+        taskRunnerCommandRequest.setFullBalance(fullBalance);
+        taskRunnerCommandRequest.setSecuritySymbol(securitySymbol);
+        taskRunnerCommandRequest.setCreditLeg_amount(creditLeg_amount);
+        taskRunnerCommandRequest.setPaymentPurpose(paymentPurpose);
+        taskRunnerCommandRequest.setSenderId(senderId);
+        taskRunnerCommandRequest.setCreditLeg_accountId(creditLeg_accountId);
+        taskRunnerCommandRequest.setAddresseeId(addresseeId);
+        taskRunnerCommandRequest.setDebitLeg_accountId(debitLeg_accountId);
         return taskRunnerCommandRequest;
     }
 
@@ -117,4 +155,76 @@ public class LauncherNew implements IAction<Object> {
     public void setSessionId(Long sessionId) {
         this.sessionId = sessionId;
     }
+
+    public BigDecimal getBalance() {
+        return balance;
+    }
+
+    public void setBalance(BigDecimal balance) {
+        this.balance = balance;
+    }
+
+    public String getSecuritySymbol() {
+        return securitySymbol;
+    }
+
+    public void setSecuritySymbol(String securitySymbol) {
+        this.securitySymbol = securitySymbol;
+    }
+
+    public BigDecimal getCreditLeg_amount() {
+        return creditLeg_amount;
+    }
+
+    public void setCreditLeg_amount(BigDecimal creditLeg_amount) {
+        this.creditLeg_amount = creditLeg_amount;
+    }
+
+    public String getPaymentPurpose() {
+        return paymentPurpose;
+    }
+
+    public void setPaymentPurpose(String paymentPurpose) {
+        this.paymentPurpose = paymentPurpose;
+    }
+
+    public Long getSenderId() {
+        return senderId;
+    }
+
+    public void setSenderId(Long senderId) {
+        this.senderId = senderId;
+    }
+
+    public Long getCreditLeg_accountId() {
+        return creditLeg_accountId;
+    }
+
+    public void setCreditLeg_accountId(Long creditLeg_accountId) {
+        this.creditLeg_accountId = creditLeg_accountId;
+    }
+
+    public Long getAddresseeId() {
+        return addresseeId;
+    }
+
+    public void setAddresseeId(Long addresseeId) {
+        this.addresseeId = addresseeId;
+    }
+
+    public Long getDebitLeg_accountId() {
+        return debitLeg_accountId;
+    }
+
+    public void setDebitLeg_accountId(Long debitLeg_accountId) {
+        this.debitLeg_accountId = debitLeg_accountId;
+    }
+
+    public BigDecimal getFullBalance() {
+        return fullBalance;
+    }
+
+    public void setFullBalance(BigDecimal fullBalance) {
+        this.fullBalance = fullBalance;
+    }
 }

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

@@ -39,7 +39,10 @@ public class FixedIncomeSecurityNewAction implements IAction<FixedIncomeSecurity
     @ApiModelProperty(value = "Размер лота", example = "300.5")
     @JsonProperty
     public BigDecimal lotSize;
-    @ApiModelProperty(value = "Номинал", example = "200.5")
+    @ApiModelProperty(value = "Текущее значение номинала", example = "200.4")
+    @JsonProperty
+    public BigDecimal nominalForDate;
+    @ApiModelProperty(value = "Номинал инструмента", example = "200.5")
     @JsonProperty
     public BigDecimal nominalValue;
     @ApiModelProperty(value = "Наименование валюты номинала", example = "RUB")
@@ -83,6 +86,7 @@ public class FixedIncomeSecurityNewAction implements IAction<FixedIncomeSecurity
         req.setIsin(this.getIsin());
         req.setBondType(this.getBondType());
         req.setLotSize(this.getLotSize());
+        req.setNominalForDate(this.getNominalForDate());
         req.setNominalValue(this.getNominalValue());
         req.setNominalCurrency(this.getNominalCurrency());
         req.setMaturityDate(this.getMaturityDate());
@@ -151,6 +155,14 @@ public class FixedIncomeSecurityNewAction implements IAction<FixedIncomeSecurity
         this.lotSize = lotSize;
     }
 
+    public BigDecimal getNominalForDate() {
+        return nominalForDate;
+    }
+
+    public void setNominalForDate(BigDecimal nominalForDate) {
+        this.nominalForDate = nominalForDate;
+    }
+
     public BigDecimal getNominalValue() {
         return nominalValue;
     }

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

@@ -41,7 +41,10 @@ public class FixedIncomeSecurityUpdateAction implements IAction<FixedIncomeSecur
     @ApiModelProperty(value = "Размер лота", example = "300.5")
     @JsonProperty
     public BigDecimal lotSize;
-    @ApiModelProperty(value = "Номинал", example = "200.5")
+    @ApiModelProperty(value = "Текущее значение номинала", example = "200.4")
+    @JsonProperty
+    public BigDecimal nominalForDate;
+    @ApiModelProperty(value = "Номинал инструмента", example = "200.5")
     @JsonProperty
     public BigDecimal nominalValue;
     @ApiModelProperty(value = "Наименование валюты номинала", example = "RUB")
@@ -85,6 +88,7 @@ public class FixedIncomeSecurityUpdateAction implements IAction<FixedIncomeSecur
         req.setIsin(this.getIsin());
         req.setBondType(this.getBondType());
         req.setLotSize(this.getLotSize());
+        req.setNominalForDate(this.getNominalForDate());
         req.setNominalValue(this.getNominalValue());
         req.setNominalCurrency(this.getNominalCurrency());
         req.setMaturityDate(this.getMaturityDate());
@@ -161,6 +165,14 @@ public class FixedIncomeSecurityUpdateAction implements IAction<FixedIncomeSecur
         this.lotSize = lotSize;
     }
 
+    public BigDecimal getNominalForDate() {
+        return nominalForDate;
+    }
+
+    public void setNominalForDate(BigDecimal nominalForDate) {
+        this.nominalForDate = nominalForDate;
+    }
+
     public BigDecimal getNominalValue() {
         return nominalValue;
     }

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

@@ -4,6 +4,7 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
 import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.profile.CompanyInfo;
 import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
 
 import java.util.ArrayList;
@@ -50,6 +51,25 @@ 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,6 +6,12 @@ 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,6 +9,11 @@ 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

@@ -1,60 +0,0 @@
-package ru.spcex.clearing.backendapi.controller.test;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonRawValue;
-import com.fasterxml.jackson.databind.JsonNode;
-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.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

@@ -1,68 +0,0 @@
-package ru.spcex.clearing.backendapi.controller.test;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JavaType;
-import com.fasterxml.jackson.databind.ObjectMapper;
-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.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;
-
-@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();
-    static {
-    }
-
-    @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);
-        log.debug("Test message to topic {} with request id={}", bankAccountNewAction.getTopicName(), idOfBaseRequestMessage);
-        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/filter/ClearingCorsFilter.java

@@ -19,14 +19,18 @@ import java.io.IOException;
 public class ClearingCorsFilter extends OncePerRequestFilter {
     private final Logger log = LoggerFactory.getLogger(getClass());
 
-private final String[] meth = new String[] {};
-    private final String[] orig = new String[] {};
+//    private final AConfigurationProperties configuration;
+    //todo cors settings
+    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
     ) {
+//        this.configuration = configuration;
         this.allowedOriginsService = allowedOriginsService;
     }
 
@@ -59,7 +63,21 @@ private final String[] meth = new String[] {};
             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,6 +12,7 @@ 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,6 +22,8 @@ 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,6 +10,9 @@ 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,6 +58,10 @@ 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();
@@ -66,7 +70,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

@@ -5,6 +5,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.utils.time.TimeUtil;
 
 import java.text.SimpleDateFormat;
@@ -34,6 +35,9 @@ public class GetResponseFactory {
                 .collect(Collectors.toList());
     }
 
+    /**
+     * dictionaryName - это имя тэга внутри <enum>
+     */
     public Map<String, Object> responseFromDictionary(String dictionaryName, Object o) {
         ObjectExtracted objectExtracted = meta.getEnumsExtractedByTagName().get(dictionaryName);
         if (objectExtracted == null) {
@@ -50,6 +54,12 @@ 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))
@@ -73,6 +83,7 @@ public class GetResponseFactory {
                     continue;
                 }
                 currentField = field;
+//                if (fieldsToAdd.contains(field.getField().getCode())) {
                     try {
                         add(r, field, field.extractValue(o));
                     } catch (Throwable e) {
@@ -85,6 +96,7 @@ public class GetResponseFactory {
                                 )))
                         );
                     }
+//                }
             }
         } catch (Exception e) {
             log.error(ExceptionUtils.getStackTrace(e));
@@ -119,8 +131,62 @@ public class GetResponseFactory {
         response.put(name, data);
     }
 
+    public Optional<Class<? extends SpcexObjectBase>> classByDestination(String destination) {
+        Map<String, ObjectExtracted> extracted = meta.getObjectsExtractedByDestination();
+        ObjectExtracted objectExtracted = extracted.get(destination);
+        if (objectExtracted == null) return Optional.empty();
+        try {
+            Class<? extends SpcexObjectBase> clazz = (Class<? extends SpcexObjectBase>) objectExtracted.getClazz();
+            return Optional.ofNullable(clazz);
+        } catch (Exception e) {
+            log.error(ExceptionUtils.getStackTrace(e));
+            return Optional.empty();
+        }
+    }
+
     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;
+//    }
 }

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

@@ -3,6 +3,7 @@ package ru.spcex.clearing.backendapi.meta;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import ru.spcex.platform.utils.log.ExceptionUtils;
+import ru.spcex.platform.utils.text.TextUtil;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
@@ -67,6 +68,8 @@ public class MetaServer extends MetaBase {
                         objectsExtractedByClazz.put(String.valueOf(classNameMock++), oe);
                     if (objectElement.getSubscription() != null && objectElement.getSubscription().destination != null) {
                         objectsExtractedByDestination.put(objectElement.getSubscription().destination, oe);
+                    } else if (!TextUtil.isEmpty(objectElement.getDestination())) {
+                        objectsExtractedByDestination.put(objectElement.getDestination(), oe);
                     }
                     for (ActionElement actionElement : objectElement.getActions()) {
                         if (actionElement.getClazz() == null) {
@@ -82,7 +85,7 @@ public class MetaServer extends MetaBase {
                             log.warn("META SERVER >>> {}", e.getLocalizedMessage());
                             continue;
                         }
-                        String actionDestination =
+                        String actionDestination = // обычно бывают =null о этому эффективнее по имени класса а не по: objectElement.getSubscription().destination + "/"+ actionElement.getDestination();
                                 oe.getClassName();
                         actionObjectsExtracted.put(actionDestination, oe);
                     }
@@ -101,6 +104,20 @@ 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);
                 }
 
@@ -113,6 +130,7 @@ 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());
                     }
@@ -124,8 +142,32 @@ 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/ObjectElement.java

@@ -18,6 +18,10 @@ public class ObjectElement {
     @JsonInclude(JsonInclude.Include.NON_EMPTY)
     private String table = null;
 
+    @JsonProperty(required = false)
+    @JsonInclude(JsonInclude.Include.NON_EMPTY)
+    private String destination = null;
+
     @JsonProperty(value = "fields", required = true)
     private List<ActionField> fields = new LinkedList<>();
 
@@ -76,4 +80,12 @@ public class ObjectElement {
     public Subscription getSubscriptionHistory() {
         return subscriptionHistory;
     }
+
+    public String getDestination() {
+        return destination;
+    }
+
+    public void setDestination(String destination) {
+        this.destination = destination;
+    }
 }

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,6 +85,7 @@ 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);

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

@@ -4,17 +4,18 @@ import org.keycloak.KeycloakPrincipal;
 import org.keycloak.adapters.spi.KeycloakAccount;
 import org.keycloak.adapters.springsecurity.token.KeycloakAuthenticationToken;
 import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.slf4j.LoggerFactory;;
 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)) {
+        if (!(authentication instanceof KeycloakAuthenticationToken)) { // AnonymousAuthenticationToken
             log.trace("Authentication token class {} is not KeycloakAuthenticationToken", authentication.getClass().getName());
             return null;
         }

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

@@ -20,6 +20,11 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.util.Map;
 
+/**
+ * при bearer only false
+ * клиент сюда не попадает
+ * срабатывает KeycloakAuthenticationProvider с редиректом на логин keycloak
+ */
 @Controller
 @RequestMapping("/sso")
 public class LoginController {

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

@@ -17,6 +17,9 @@ public class RestTemplateConfig {
         this.builder = builder;
     }
 
+    /**
+     * В настоящий момент используется для выгрузки AFS данных
+     */
     @Bean("clearing-rest")
     public RestTemplate restTemplate() {
         return builder

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

@@ -6,8 +6,10 @@ import org.springframework.stereotype.Component;
 
 @Component
 public class SimpleUserDetailService
+//        implements UserDetailsService
 {
-public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+//    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
         return null;
     }
 }

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

@@ -52,7 +52,11 @@ public class WebSecurityConfig extends KeycloakWebSecurityConfigurerAdapter {
     protected void configure(HttpSecurity http) throws Exception {
         super.configure(http);
         ExpressionUrlAuthorizationConfigurer<HttpSecurity>.AuthorizedUrl anyReq = http
-.cors()
+//                .formLogin()
+//                .loginProcessingUrl("/backend-api-login/perform-login")
+//                .and()
+                //todo remove? see ClearingCorsFilter
+                .cors()
                 .and()
                 .csrf().disable()
                 .authorizeRequests()
@@ -80,6 +84,7 @@ public class WebSecurityConfig extends KeycloakWebSecurityConfigurerAdapter {
 
     @Bean
     public GrantedAuthorityDefaults grantedAuthorityDefaults() {
+        // Remove the ROLE_ prefix
         return new GrantedAuthorityDefaults("");
     }
 

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

@@ -8,5 +8,16 @@ import java.util.concurrent.ExecutionException;
 public interface IOperator {
     QueueSuccessResponse sendRequestToQueue(String destination, IAction<?> iAction, boolean appendUserId) throws ExecutionException, InterruptedException;
 
+    /**
+     * Для оптимизации проставления userId.
+     * Аналог sendRequestToQueue(String destination, IAction<?> iAction, true)
+     *
+     * @param destination
+     * @param iAction
+     * @param userId совершивший запрос
+     * @return
+     * @throws ExecutionException
+     * @throws InterruptedException
+     */
     QueueSuccessResponse sendRequestToQueue(String destination, IAction<?> iAction, Long userId) throws ExecutionException, InterruptedException;
 }

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

@@ -1,15 +1,25 @@
 package ru.spcex.clearing.backendapi.service;
 
 import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
 
+/**
+ * сделал чтобы не привязывать все контроллеры к Imdg API
+ */
 public interface IStateLoader {
     <T extends SpcexObjectBase> Optional<T> getById(Long id, String mapName, Class<T> clazz);
     <T extends SpcexObjectBase> Collection<T> getAll(String mapName, Class<T> clazz);
     <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz);
     <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransformSpecificClass(String mapName, Class<T> clazz);
     <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz, Map<String, ? extends Comparable<?>> conditions);
+    <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz, ImdgPredicate conditions);
+    <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(
+            String searchMapName,
+            String mapName,
+            Class<T> clazz,
+            ImdgPredicate conditions);
 }

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

@@ -14,6 +14,10 @@ import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 
+/**
+ * Сервис для сигнализирования результатов запросов клиентов. Ассинхронное обновление статуса.
+ * Клиент запрашивает периодически (или по событию) таблицу Map_RequestInfo и видит результат выполнения запросов.
+ */
 @Service
 public class RequestInfoAccepter extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -35,10 +39,17 @@ public class RequestInfoAccepter extends QueueConsumer implements InitializingBe
     }
 
     private void updateRequestInfo(BaseRequest<RequestInfoUpdate> requestInfoUpdateBaseRequest) {
+        //will throw exception for any class other than RequestInfoUpdate
         RequestInfoUpdate statusInfo = requestInfoUpdateBaseRequest.getRequestPayload();
+        if (statusInfo == null || statusInfo.getId() == null) {
+            log.warn("BaseRequest id={}, RequestPayload={}: requestInfo id was null",
+                    requestInfoUpdateBaseRequest.getId(), statusInfo);
+            return;
+        }
         RequestInfo requestInfo = requestInfoImdg.getSingleObjectByID(statusInfo.getId());
         if (requestInfo == null) {
-            log.warn("unknown requestInfo id={}", statusInfo.getId());
+            log.warn("unknown requestInfo id={}; statusInfo: {}",
+                    statusInfo.getId(), statusInfo);
             return;
         }
         requestInfo.setStatus(statusInfo.getStatus());

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

@@ -40,7 +40,7 @@ public class UserAuthProcessor {
         requestData.setUsername(identifier);
         requestData.setTime(Instant.now());
         requestData.setRoles(new ArrayList<>(roles));
-        requestData.setServerIp(serverIp + ":" + serverPort);
+        requestData.setServerIp(serverIp + ":" + serverPort); //getServerAddress() + ":" + serverPort
         requestData.setClientIp(userIp);
         requestData.setEmail(email);
         requestData.setName(name);
@@ -48,7 +48,7 @@ public class UserAuthProcessor {
         requestData.setMiddleName(middleName);
         try {
             operator.sendRequestToQueue(Consts.USER_AUTH_SUCCESS, authEvent, false);
-        } catch (Throwable e) {
+        } catch (Throwable e) { //ExecutionException | InterruptedException
             log.error(ExceptionUtils.getStackTrace(e));
         }
     }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/OperatorImpl.java

@@ -62,8 +62,10 @@ public class OperatorImpl implements IOperator {
         if (user == null) {
             log.warn("UserID not found by login \"{}\"", username);
             return null;
+            //throw new IllegalStateException("cannot obtain userId from logged in user " + username);
         }
         return user.getId();
+        // todo добавить кэш, с очисткой по времени
     }
 
     @Override
@@ -76,6 +78,7 @@ public class OperatorImpl implements IOperator {
         if (appendUserId) {
             request.setUserId(currentUserId());
         }
+        //сохраняет данные о запросе в хранилище
         saveRequestToStorage(destination, request);
         Future<RecordMetadata> send = kafka.send(new ProducerRecord<>(destination, request));
         send.get();
@@ -95,6 +98,7 @@ public class OperatorImpl implements IOperator {
         } else {
             request.setUserId(userId);
         }
+        //сохраняет данные о запросе в хранилище
         saveRequestToStorage(destination, request);
         Future<RecordMetadata> send = kafka.send(new ProducerRecord<>(destination, request));
         send.get();
@@ -110,10 +114,12 @@ public class OperatorImpl implements IOperator {
     }
 
     private void throwValidate(String destination, IAction<?> iAction) {
+        //простая валидация - которую можно запилить прямо внутри класса (наличие полей, отношения между датами etc.)
         Collection<EnumMessage> validationErrors = iAction.validate();
         if (validationErrors.size() > 0) {
             throw new ActionValidationException(validationErrors);
         }
+        // Валидация по мете (рекомендуется использовать её,а не iAction.validate();
         IValidator metaValidator = actionMetaValidation.getValidator(destination, iAction);
         if (metaValidator != null) {
             metaValidator.tillFirstError().ifPresent(enumMessage -> {
@@ -124,6 +130,8 @@ public class OperatorImpl implements IOperator {
                 }
             });
         }
+
+        //валидация требующая IMDG поиска других сущностей и т.д.
         IValidator validator = validation.getValidator(destination, iAction);
         if (validator != null) {
             validator.tillFirstError().ifPresent(enumMessage -> {

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java

@@ -1,28 +1,33 @@
 package ru.spcex.clearing.backendapi.service.impl;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 import ru.spcex.clearing.backendapi.meta.GetResponseFactory;
 import ru.spcex.clearing.backendapi.service.IStateLoader;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 
-import java.util.Collection;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
 @Service
 public class StateLoaderImpl implements IStateLoader {
     private final Map<String, Imdg<?>> allImdgMaps;
+    private final Map<String, Imdg<?>> allHistMaps;
     private final ImdgProvider imdgProvider;
+    private final ImdgProvider imdgHistProvider;
     private final GetResponseFactory responseFactory;
 
     @Autowired
-    public StateLoaderImpl(ImdgProvider imdgProvider, GetResponseFactory responseFactory) {
+    public StateLoaderImpl(@Qualifier("imdgProvider") ImdgProvider imdgProvider,
+                           @Qualifier("imdgProviderHist") ImdgProvider imdgHistProvider, GetResponseFactory responseFactory) {
+        this.imdgHistProvider = imdgHistProvider;
         this.responseFactory = responseFactory;
         this.allImdgMaps = new ConcurrentHashMap<>();
+        this.allHistMaps = new HashMap<>();
         this.imdgProvider = imdgProvider;
     }
 
@@ -59,8 +64,38 @@ public class StateLoaderImpl implements IStateLoader {
         return responseFactory.responseFromObjectCollection(all);
     }
 
+    @Override
+    public <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName,
+                                                                                           Class<T> clazz,
+                                                                                           ImdgPredicate conditions) {
+        Imdg<T> imdg = getImdg(mapName, clazz);
+        Collection<T> all = imdg.getCollectionObjectsByPredicate(conditions);
+        return responseFactory.responseFromObjectCollection(all);
+    }
+
     @SuppressWarnings("unchecked")
     private <T extends SpcexObjectBase> Imdg<T> getImdg(String mapName, Class<T> clazz) {
         return (Imdg<T>) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProvider.getImdg(mapName, clazz));
     }
+
+    @SuppressWarnings("unchecked")
+    private <T extends SpcexObjectBase> Imdg<T> getHistImdg(String mapName, Class<T> clazz) {
+        return (Imdg<T>) allHistMaps.computeIfAbsent(mapName, (mapName1) -> imdgHistProvider.getImdg(mapName, clazz));
+    }
+
+    @Override
+    public <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(
+            String searchMapName,
+            String mapName,
+            Class<T> clazz,
+            ImdgPredicate conditions) {
+        Imdg<SpcexObjectBase> imdgSearch = getHistImdg(searchMapName, SpcexObjectBase.class);
+        Imdg<T> imdgHistory = getHistImdg(mapName, clazz);
+        Collection<Long> ids = imdgSearch.getCollectionIdsByPredicate(conditions);
+        return ids.stream()
+                .map(imdgHistory::getSingleObjectByID)
+                .filter(Objects::nonNull)
+                .map(o -> responseFactory.responseFromObject(o, clazz))
+                .toList();
+    }
 }