ANLT & TCR search

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

@@ -21,6 +21,7 @@ import ru.clearing.classes.statics.data.misc.Session;
 import ru.clearing.classes.statics.data.payment.PaymentInstruction;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
 import ru.clearing.classes.statics.data.sdf.SDf01;
 import ru.clearing.classes.statics.data.sdf.SDf06;
 import ru.clearing.classes.statics.data.sdf.SDf08;
@@ -103,6 +104,7 @@ public class ValidationConfig {
     Imdg<Security> imdgSecurity;
     Imdg<MoneyMarketSecurity> imdgMoneyMarketSecurity;
     Imdg<TradingClearingRegistry> imdgTradingClearingRegistry;
+    Imdg<TradingClearingRegistryList> imdgTradingClearingRegistryList;
     Imdg<Session> imdgSession;
     Imdg<SectionDictionary> imdgSectionDictionary;
     Imdg<Statement> imdgStatement;
@@ -124,6 +126,8 @@ public class ValidationConfig {
         this.imdgAccountBalance = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
         this.imdgSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.imdgTradingClearingRegistry = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+        this.imdgTradingClearingRegistryList
+            = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
         this.imdgSession = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
         this.imdgSectionDictionary = imdgProvider.getImdg(IMDGDistributedNames.Map_SectionDictionary, SectionDictionary.class);
         this.imdgMoneyMarketSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
@@ -350,6 +354,7 @@ public class ValidationConfig {
             context.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
             context.addImdg(IMDGDistributedNames.Map_Session, imdgSession);
             context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
+            context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, imdgTradingClearingRegistryList);
             context.addImdg(IMDGDistributedNames.Map_Currency, imdgCurrency);
             context.setLogPrefix(LogPrefixId.INSTANCE);
             return new ValidatorImpl<>(context,

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/AnltSearcher.java

@@ -1,5 +1,7 @@
 package ru.spcex.clearing.service;
 
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -7,9 +9,11 @@ import org.springframework.stereotype.Component;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
 import ru.spcex.clearing.error.ClearingError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.CurrencyCode;
 import ru.spcex.platform.enumeration.ServiceStatus;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
@@ -19,25 +23,25 @@ import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumId;
 import ru.spcex.platform.utils.text.TextUtil;
 
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
 @Component
 public class AnltSearcher {
     private Logger log = LoggerFactory.getLogger(getClass());
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
     private final Imdg<Company> companyImdg;
     private final Imdg<Account> accountImdg;
+    private Imdg<TradingClearingRegistryList> tcrListImdg;
 
     @Autowired
     public AnltSearcher(ImdgProvider imdgProvider) {
         this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        this.tcrListImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
     }
 
-    public AnltSearcher(Imdg<TradingClearingRegistry> tcrImdg, Imdg<Company> companyImdg, Imdg<Account> accountImdg) {
+    public AnltSearcher(Imdg<TradingClearingRegistry> tcrImdg, Imdg<TradingClearingRegistryList> tcrListImdg, Imdg<Company> companyImdg, Imdg<Account> accountImdg) {
         this.tradingClearingRegistryImdg = tcrImdg;
+        this.tcrListImdg = tcrListImdg;
         this.companyImdg = companyImdg;
         this.accountImdg = accountImdg;
     }
@@ -47,33 +51,58 @@ public class AnltSearcher {
         void log(IEnumId subject, Object... args);
     }
 
+
     public AnltSearch loadByAnlt(String comment) {
+        return loadByAnlt(comment, CurrencyCode.RUB.getKey());
+    }
+
+    public AnltSearch loadByAnlt(String comment, String currencyCode) {
         String commentTcrStripped = getTkrCodeFromComment(comment);
 //        AnltLogger localLogger = (subject, args) -> log.debug("stmt.id={} comment='{}' error: {}", statementId, commentTcrStripped, messageResolver.resolve(new EnumMessage(subject, args)));
         if (commentTcrStripped == null) {
             return new AnltSearch(ClearingError.AccountNotFound, "comment not contain TCR");
         }
         ImdgPredicateBuilder pb = tradingClearingRegistryImdg.predicateBuilder();
-        ImdgPredicate tcrPredicate = pb.and(
+        ImdgPredicate statusPrdct = pb.or(
-                pb.equals("code", commentTcrStripped),
+            pb.equals("status", ServiceStatus.Active.getKey()),
-                pb.or(
+            pb.equals("status", ServiceStatus.Reopened.getKey())
-                        pb.equals("status", ServiceStatus.Active.getKey()),
-                        pb.equals("status", ServiceStatus.Reopened.getKey())
-                )
         );
-
+        ImdgPredicate tcrPredicate = pb.and(
+            pb.equals("code", commentTcrStripped),
+            statusPrdct
+        );
+        TradingClearingRegistryList tcrList = null;
         TradingClearingRegistry tcr = tradingClearingRegistryImdg.getSingleObjectByPredicate(tcrPredicate);
         if (tcr == null) {
             return new AnltSearch(ClearingError.TCRegistryNotFound, commentTcrStripped);
         }
 
-        if (tcr.getMoneyAccountId() == null) {
+        Account infoAcc = null;
-            return new AnltSearch(ClearingError.WrongField, "moneyAccountId");
+        if (CurrencyCode.isRub(currencyCode)) {
+            if (tcr.getMoneyAccountId() == null) {
+                return new AnltSearch(ClearingError.WrongField, "moneyAccountId");
+            }
+            infoAcc = accountImdg.getSingleObjectByID(tcr.getMoneyAccountId());
+        } else {
+            tcrList = tcrListImdg.getSingleObjectByPredicate(
+                pb.and(
+                    pb.equals("currency", currencyCode),
+                    pb.equals("tradingClearingRegistryId", tcr.getId()),
+                    statusPrdct
+                )
+            );
+            if (tcrList == null) {
+                return new AnltSearch(ClearingError.TCRegistryNotFound, "<by commend=%s and currency=%s>"
+                    .formatted(comment, currencyCode));
+            }
+            infoAcc = accountImdg.getSingleObjectByID(tcrList.getAccountId());
         }
 
-        Account infoAcc = accountImdg.getSingleObjectByID(tcr.getMoneyAccountId());
         if (infoAcc == null) {
-            return new AnltSearch(ClearingError.AccountNotFound, "moneyAccountId");
+            return new AnltSearch(ClearingError.AccountNotFoundB,
+                "<for tcr.id=%d/moneyAccountId=%d> currency %s".formatted(
+                    tcr.getId(), tcr.getMoneyAccountId(), currencyCode
+                ));
         }
 
         if (!infoAcc.getAccountType().equals(AccountType.Info.getKey())) {
@@ -84,7 +113,7 @@ public class AnltSearcher {
         if (company == null) {
             return new AnltSearch(ClearingError.CompanyNotFoundB, tcr.getCompanyId());
         }
-        return new AnltSearch(infoAcc, company, tcr);
+        return new AnltSearch(infoAcc, company, tcr, tcrList, currencyCode);
     }
 
     private static final Pattern tcrPattern = Pattern.compile("ТКР.*?([0-9A-Z-]{12})");
@@ -107,15 +136,33 @@ public class AnltSearcher {
         private Account account;
         private Company company;
         private TradingClearingRegistry tcr;
+        private TradingClearingRegistryList tcrList;
+        private String currency;
 
         public AnltSearch(IEnumId errSubject, Object... args) {
             this.error = new EnumMessage(errSubject, args);
         }
 
+        public AnltSearch() {
+        }
+
         public AnltSearch(Account account, Company company, TradingClearingRegistry tcr) {
             this.account = account;
             this.company = company;
             this.tcr = tcr;
+            this.currency = CurrencyCode.RUB.getKey();
+        }
+
+        public AnltSearch(Account account,
+                          Company company,
+                          TradingClearingRegistry tcr,
+                          TradingClearingRegistryList tcrList,
+                          String currency) {
+            this.account = account;
+            this.company = company;
+            this.tcr = tcr;
+            this.tcrList = tcrList;
+            this.currency = CurrencyCode.RUB.getKey();
         }
 
         public boolean isFound() {
@@ -153,5 +200,21 @@ public class AnltSearcher {
         public void setTcr(TradingClearingRegistry tcr) {
             this.tcr = tcr;
         }
+
+        public TradingClearingRegistryList getTcrList() {
+            return tcrList;
+        }
+
+        public void setTcrList(TradingClearingRegistryList tcrList) {
+            this.tcrList = tcrList;
+        }
+
+        public String getCurrency() {
+            return currency;
+        }
+
+        public void setCurrency(String currency) {
+            this.currency = currency;
+        }
     }
 }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/TcrSearcher.java

@@ -0,0 +1,99 @@
+package ru.spcex.clearing.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+import ru.spcex.clearing.error.ClearingError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.enumeration.CurrencyCode;
+import ru.spcex.platform.enumeration.ServiceStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+
+@Component
+public class TcrSearcher {
+    private Logger log = LoggerFactory.getLogger(getClass());
+    private final Imdg<TradingClearingRegistry> tcrImdg;
+    private final Imdg<TradingClearingRegistryList> tcrListImdg;
+    private final Imdg<Company> companyImdg;
+    private final Imdg<Account> accountImdg;
+
+
+    @Autowired
+    public TcrSearcher(ImdgProvider imdgProvider) {
+        this.tcrImdg = imdgProvider.getImdg(
+            IMDGDistributedNames.Map_TradingClearingRegistry,
+            TradingClearingRegistry.class);
+        this.tcrListImdg = imdgProvider.getImdg(
+            IMDGDistributedNames.Map_TradingClearingRegistryList,
+            TradingClearingRegistryList.class);
+        this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+    }
+
+    public TcrSearcher(Imdg<TradingClearingRegistry> tcrImdg,
+                       Imdg<TradingClearingRegistryList> tcrListImdg,
+                       Imdg<Company> companyImdg,
+                       Imdg<Account> accountImdg) {
+        this.tcrImdg = tcrImdg;
+        this.tcrListImdg = tcrListImdg;
+        this.companyImdg = companyImdg;
+        this.accountImdg = accountImdg;
+    }
+
+    public AnltSearcher.AnltSearch loadByCurrencyAccountId(Long accountId, String currency) {
+        AnltSearcher.AnltSearch srchRes = new AnltSearcher.AnltSearch();
+        ImdgPredicateBuilder pb = tcrImdg.predicateBuilder();
+        ImdgPredicate sttsPrdct = pb.or(
+            pb.equals("status", ServiceStatus.Active.getKey()),
+            pb.equals("status", ServiceStatus.Reopened.getKey())
+        );
+        //fixme BASED ON CURRENCY
+        TradingClearingRegistry tcr = tcrImdg.getSingleObjectByPredicate(
+            pb.and(
+                pb.equals("moneyAccountId", accountId),
+                sttsPrdct
+            )
+        );
+
+        if (tcr != null) {
+            srchRes.setCurrency(CurrencyCode.RUB.getKey());
+        } else {
+            TradingClearingRegistryList tcrList = tcrListImdg.getSingleObjectByPredicate(
+                pb.and(
+                    pb.equals("accountId", accountId),
+                    sttsPrdct
+                )
+            );
+            if (tcrList == null) {
+                return new AnltSearcher.AnltSearch(ClearingError.TCRegistryNotFound, "<by accountId=%s".formatted(accountId));
+            }
+            tcr = tcrImdg.getSingleObjectByID(tcrList.getTradingClearingRegistryId());
+            if (tcr == null) {
+                return new AnltSearcher.AnltSearch(ClearingError.TCRegistryNotFound, "<by accountId=%s".formatted(accountId));
+            }
+            srchRes.setCurrency(tcrList.getCurrency());
+            srchRes.setTcrList(tcrList);
+        }
+        srchRes.setTcr(tcr);
+
+        Account acc = accountImdg.getSingleObjectByID(accountId);
+        if (acc == null) {
+            return new AnltSearcher.AnltSearch(ClearingError.AccountNotFoundB, accountId);
+        }
+        Company cmp = companyImdg.getSingleObjectByID(acc.getCompanyId());
+        if (cmp == null) {
+            return new AnltSearcher.AnltSearch(ClearingError.CompanyNotFoundB, acc.getCompanyId());
+        }
+        srchRes.setAccount(acc);
+        srchRes.setCompany(cmp);
+        return srchRes;
+    }
+}

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistryBuilder.java

@@ -1,5 +1,9 @@
 package ru.spcex.clearing.service.builder;
 
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.Map;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.ClearingAccount;
 import ru.clearing.classes.statics.data.company.Company;
@@ -13,18 +17,19 @@ import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
 import ru.clearing.classes.statics.data.security.Security;
 import ru.clearing.classes.statics.data.statement.Statement;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.service.AnltSearcher;
+import ru.spcex.clearing.service.TcrSearcher;
 import ru.spcex.clearing.session.stage.util.RegistryUtil;
-import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.RegistryCapacity;
+import ru.spcex.platform.enumeration.RegistryDesignation;
+import ru.spcex.platform.enumeration.RegistryInstrumentType;
+import ru.spcex.platform.enumeration.RegistryStatus;
+import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 
-import java.math.BigDecimal;
-import java.time.Instant;
-import java.time.LocalDate;
-import java.util.Collection;
-import java.util.Map;
-
 public class RegistryBuilder {
     private Statement statement;
     private Company company;
@@ -40,6 +45,8 @@ public class RegistryBuilder {
     private final Imdg<EquitySecurity> equitySecurityImdg;
     private final Imdg<CurrencyPairSecurity> currencyPairSecurityImdg;
     private final Imdg<Currency> currencyImdg;
+    private final TcrSearcher tcrSrcher;
+    private String currency;
 
 
     public static RegistryBuilder builder(ImdgProvider imdgProvider) {
@@ -56,6 +63,7 @@ public class RegistryBuilder {
         this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
         this.currencyPairSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class);
         this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
+        this.tcrSrcher = new TcrSearcher(imdgProvider);
     }
 
     public RegistryBuilder statement(Statement statement) {
@@ -73,6 +81,11 @@ public class RegistryBuilder {
         return this;
     }
 
+    public RegistryBuilder loadTcrForCurrency(String currency) {
+        this.currency = currency;
+        return this;
+    }
+
     public RegistryBuilder designation(RegistryDesignation designation) {
         this.designation = designation;
         return this;
@@ -103,15 +116,13 @@ public class RegistryBuilder {
         rgs.setRegistryUnit(RegistryUnit.T.getKey());
         rgs.setRegistryCode(RegistryUtil.clearingCode(rgs));
 
-        Collection<TradingClearingRegistry> tcrsByAccount = tradingClearingRegistryImdg.getCollectionObjectsByFieldValues(Map.of(
+        if (currency != null) {
-                "moneyAccountId", account.getId(),
+            AnltSearcher.AnltSearch anltSearch = tcrSrcher.loadByCurrencyAccountId(account.getId(), currency);
-                "companyId", company.getId(),
+            if (anltSearch.isFound()) {
-                "status", ServiceStatus.Active.getKey()
+                TradingClearingRegistry tcr = anltSearch.getTcr();
-        ));
+                rgs.setTradingClearingRegistryId(tcr.getId());
-        if (!tcrsByAccount.isEmpty()) {
+                rgs.setTradingClearingRegistry(tcr.getCode());
-            TradingClearingRegistry tcr = tcrsByAccount.iterator().next();
+            }
-            rgs.setTradingClearingRegistryId(tcr.getId());
-            rgs.setTradingClearingRegistry(tcr.getCode());
         }
 
         rgs.setRegistryStatus(RegistryStatus.PROC.getKey());

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf01Executor.java

@@ -180,6 +180,7 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
                             .company(company)
                             .account(account)
                             .designation(RegistryDesignation.A)
+                            .loadTcrForCurrency(sdf01.getCurr_code())
                             .build();
                     calcBalance(rgs, stmt);
                     Registry registryB = copyRegB(rgs);

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf06Executor.java

@@ -40,7 +40,6 @@ import ru.spcex.clearing.service.schedule.TradingTimeService;
 import ru.spcex.clearing.service.validation.Sdf06NewValidationRule;
 import ru.spcex.clearing.service.validation.ValidationStored;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
-import ru.spcex.platform.enumeration.CurrencyCode;
 import ru.spcex.platform.enumeration.InOutDirection;
 import ru.spcex.platform.enumeration.InOutSDfType;
 import ru.spcex.platform.enumeration.OperationStatus;
@@ -173,7 +172,7 @@ public class Sdf06Executor {
                 processedApproved(stmt, sDf06, now, sdf07GroupId);
                 if (tcr != null) {
                     dmiService.setProcContract(tcr.getId(),
-                            CurrencyCode.RUB.getKey(), //fixme???
+                            sDf06.getPay_val(),
                             safeBD(sDf06.getSum()),
                             sDf06.getNumber().toString());
                     Optional<AssetTrio> asts = assets.searchMoneyByAccAndCompany(company.getId(), tcr.getMoneyAccountId());
@@ -286,7 +285,7 @@ public class Sdf06Executor {
                 processedApproved(stmt, sdf06, updatedTime);
                 Optional<TradingClearingRegistry> tcr = searchTcrOnGatewayResponse(sdf06);
                 dmiService.setProcContract(tcr.map(SpcexObjectBase::getId).orElse(null),
-                        CurrencyCode.RUB.getKey(), //fixme???
+                        sdf06.getPay_val(),
                         safeBD(sdf06.getSum()),
                         sdf06.getNumber().toString()
                 );

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java

@@ -278,6 +278,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                                 .statement(stmt)
                                 .company(company)
                                 .account(account)
+                                .loadTcrForCurrency(sdf57.getPay_val())
                                 .designation(RegistryDesignation.A)
                                 .build();
                         calcBalance(registry, stmt, sdf57);
@@ -418,7 +419,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                 Account acc = stmtCmpAcc.account();
                 Optional<AssetTrio> asts = createRegistryIfNeeded.apply(stmtCmpAcc);
                 if (accountIsAnlt(acc)) {
-                    AnltSearcher.AnltSearch searchResult = anltSearcher.loadByAnlt(stmt.getComment());
+                    AnltSearcher.AnltSearch searchResult = anltSearcher.loadByAnlt(stmt.getComment(), sdf57.getPay_val());
                     if (searchResult.isFound()) {
                         log.debug("stmt.id={} comment={} is anlt, loaded account.id={}/companyId={}",
                                 stmt.getId(),

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

@@ -1,35 +1,39 @@
 package ru.spcex.clearing.service.validation;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import ru.clearing.classes.statics.data.account.Account;
-import ru.clearing.classes.statics.data.company.Company;
-import ru.clearing.classes.statics.data.misc.Session;
-import ru.clearing.classes.statics.data.registry.Registry;
-import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
-import ru.clearing.classes.statics.data.sdf.SDf06;
-import ru.spcex.clearing.error.ClearingError;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.service.AnltSearcher;
-import ru.spcex.platform.enumeration.*;
-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.api.predicate.specific.RegistryCodeSqlBuilder;
-import ru.spcex.platform.imdg.validation.ImdgValidationContext;
-import ru.spcex.platform.utils.enumeration.EnumMessage;
-import ru.spcex.platform.utils.number.BigDecimalUtil;
-import ru.spcex.platform.utils.text.TextUtil;
-import ru.spcex.platform.utils.validation.IValidationRule;
-
 import java.math.BigDecimal;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
-
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.misc.Session;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+import ru.clearing.classes.statics.data.sdf.SDf06;
+import ru.spcex.clearing.error.ClearingError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.service.AnltSearcher;
+import ru.spcex.clearing.service.TcrSearcher;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.InOutDirection;
+import ru.spcex.platform.enumeration.RegistryStatus;
+import ru.spcex.platform.enumeration.RegistryTradingParams;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.number.BigDecimalUtil;
 import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
+import ru.spcex.platform.utils.text.TextUtil;
+import ru.spcex.platform.utils.validation.IValidationRule;
 
 public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationContext<SDf06>> {
     Fields() {
@@ -165,7 +169,9 @@ public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationCont
                 dir = (InOutDirection.out);
             }
             Imdg<TradingClearingRegistry> tcrImdg;
+            Imdg<TradingClearingRegistryList> tcrListImdg;
             tcrImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+            tcrListImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
             //если направление in то ТКР необязателен
             Function<Optional<EnumMessage>, Optional<EnumMessage>> err = msg -> {
                 if (dir.equals(InOutDirection.in)) {
@@ -177,16 +183,16 @@ public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationCont
                 }
             };
             AnltSearcher.AnltSearch anltSrch;
+            Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
+            Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
             if (AccountType.Anlt.getKey().equals(account.getAccountType())) {
                 log.debug("account.id={} is ANLT", account.getId());
                 if (TextUtil.isEmpty(sdf06.getSpec())) {
                     log.debug("ANLT couldn't find by account.id={} spec empty", account.getId());
                     return err.apply(of(ClearingError.TCRegistryNotFound, "<spec empty>"));
                 }
-                Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
+                AnltSearcher anltSearcher = new AnltSearcher(tcrImdg, tcrListImdg, companyImdg, accountImdg);
-                Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+                anltSrch = anltSearcher.loadByAnlt(sdf06.getSpec(), sdf06.getPay_val());
-                AnltSearcher anltSearcher = new AnltSearcher(tcrImdg, companyImdg, accountImdg);
-                anltSrch = anltSearcher.loadByAnlt(sdf06.getSpec());
                 if (!anltSrch.isFound()) {
                     log.debug("ANLT couldn't find by account.id={} by spec {}", account.getId(), sdf06.getSpec());
                     return err.apply(of(ClearingError.TCRegistryNotFound, sdf06.getSpec()));
@@ -200,11 +206,10 @@ public enum Sdf06NewValidationRule implements IValidationRule<ImdgValidationCont
                     return empty();
                 }
             } else {
-                TradingClearingRegistry tcr = tcrImdg.getFirstObjectByFieldValues(
+                TcrSearcher tcrSearcher = new TcrSearcher(tcrImdg, tcrListImdg, companyImdg, accountImdg);
-                        Map.of("moneyAccountId", account.getId())
+                AnltSearcher.AnltSearch anltSearch = tcrSearcher.loadByCurrencyAccountId(account.getId(), sdf06.getPay_val());
-                );
+                if (anltSearch.isFound()) {
-                if (tcr != null) {
+                    context.storeObject(ValidationStored.Sdf06Tcr, anltSearch.getTcr());
-                    context.storeObject(ValidationStored.Sdf06Tcr, tcr);
                     return empty();
                 } else {
                     log.debug("couldn't find TCR by account.id={} accountType {}",