currency: sdf06/sdf55/sdf57/identification funds/outbound payment

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

@@ -46,6 +46,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistryChangeRe
 import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistryChangeStatusExtractRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistryReturnDepositRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.registry.RegistrySplitDepositActionRequest;
+import ru.spcex.clearing.service.validation.AnltAccLoad;
 import ru.spcex.clearing.service.validation.ClrngValidationStored;
 import ru.spcex.clearing.service.validation.CompanyByTradingCodeValidationRule;
 import ru.spcex.clearing.service.validation.CurrencyCodeValidationRule;
@@ -79,7 +80,6 @@ import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.imdg.validation.LogPrefixId;
-import ru.spcex.platform.imdg.validation.rule.AnltAccLoad;
 import ru.spcex.platform.imdg.validation.rule.PresentById;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.validation.IValidator;
@@ -458,6 +458,7 @@ public class ValidationConfig {
             context.setValidatedObject(identificationFundsRequest);
             context.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
             context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
+            context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistryList, imdgTradingClearingRegistryList);
             context.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
             context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
             context.setLogPrefix(LogPrefixId.INSTANCE);
@@ -556,6 +557,7 @@ public class ValidationConfig {
             ImdgValidationContext<StatementRequest> ctx = new ImdgValidationContext<>();
             ctx.setValidatedObject(req);
             ctx.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
+            ctx.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
             ctx.addImdg(IMDGDistributedNames.Map_SDf55, sDf55Imdg);
             ctx.addImdg(IMDGDistributedNames.Map_SDf54, sDf54Imdg);
             ctx.addImdg(IMDGDistributedNames.Map_PaymentInstruction, pmtImdg);

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

@@ -685,6 +685,7 @@ public class RegistryService {
         AssetOperationListRequest gatewayRequest = new AssetOperationListRequest();
         AssetOperationRequest req = GatewayRequestCreator.from(
                 dmau.getId(),
+                dmau.getSecuritySymbol(),
                 null,
                 balance,
                 InOutDirection.in,

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

@@ -53,9 +53,19 @@ public class TcrSearcher {
 
     public Optional<Account> searchByTcr(Long tcrId, String currency) {
         TradingClearingRegistry tcr = tcrImdg.getSingleObjectByID(tcrId);
-        if (tcr == null || (CurrencyCode.RUB.equalsByKey(currency) && tcr.getMoneyAccountId() == null)) {
+        if (tcr == null) {
             log.warn("couldn't find account by tcr#id={}; currency {}. TCR {}",
-                tcrId, currency, tcr != null ? "found" : "not found");
+                tcrId, currency, "not found");
+            return Optional.empty();
+        }
+        return searchByTcr(tcr, currency);
+    }
+
+    public Optional<Account> searchByTcr(TradingClearingRegistry tcr, String currency) {
+        Long tcrId = tcr.getId();
+        if ((CurrencyCode.RUB.equalsByKey(currency) && tcr.getMoneyAccountId() == null)) {
+            log.warn("couldn't find account by tcr#id={}; currency {}. TCR#id={}",
+                tcrId, currency, tcr.getId());
             return Optional.empty();
         }
         if (CurrencyCode.RUB.equalsByKey(currency)) {

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

@@ -34,6 +34,7 @@ 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.utils.enumeration.IEnumKey;
+import ru.spcex.platform.utils.text.TextUtil;
 import ru.spcex.platform.utils.time.TimeUtil;
 
 public class PaymentInstructionBuilderV2 {
@@ -189,12 +190,12 @@ public class PaymentInstructionBuilderV2 {
         }
 
         payment.setDebit_csAccount(null);
-        if (currency != null) {
+        if (TextUtil.isEmpty(currency)) {
-            payment.setCreditLeg_currencyCode(currency);
-            payment.setDebitLeg_currencyCode(currency);
-        } else {
             payment.setCreditLeg_currencyCode(CurrencyCode.RUB.getKey());
             payment.setDebitLeg_currencyCode(CurrencyCode.RUB.getKey());
+        } else {
+            payment.setCreditLeg_currencyCode(currency);
+            payment.setDebitLeg_currencyCode(currency);
         }
         payment.setTransactionStatus(TransactionStatus.stld.getKey());
         payment.setDocumentNumber(nextDocumentNumber(registry, payment));

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

@@ -138,6 +138,7 @@ public class Sdf06Executor {
         for (SDf06 sDf06 : sdfs) {
             IValidator validator = sDf06Validator.apply(sDf06);
             Optional<EnumMessage> err = validator.tillFirstError();
+            Account account = validator.getStored(ValidationStored.Sdf06Account);
             if (err.isPresent()) {
                 log.debug("sdf06.id={} validation error: {}", sDf06.getId(), messageResolver.resolve(err.get()));
                 SDf07 errorSdf07;
@@ -146,7 +147,7 @@ public class Sdf06Executor {
                 if (needToCreateStatement(err.get())) {
                     stmt = createStatementBySdf06(sDf06,
                             ((Company) validator.getStored(ValidationStored.Sdf06Company)).getId(),
-                            validator.getStored(ValidationStored.Sdf06Account), null);
+                        account, null);
                 }
                 errorSdf07 = createSdf07(sDf06, now, errorResult);
                 errorSdf07.setGenerationId(sdf07GroupId);
@@ -165,7 +166,7 @@ public class Sdf06Executor {
             //проверка существует ли statement пока убрал
             Statement stmt = createStatementBySdf06(sDf06,
                 company.getId(),
-                validator.getStored(ValidationStored.Sdf06Account),
+                account,
                 currency.getId());
             statementImdg.insert(stmt);
             log.debug("Statement created: {}", stmt.getId());
@@ -179,7 +180,7 @@ public class Sdf06Executor {
                             sDf06.getPay_val(),
                             safeBD(sDf06.getSum()),
                             sDf06.getNumber().toString());
-                    Optional<AssetTrio> asts = assets.searchMoneyByAccAndCompany(company.getId(), tcr.getMoneyAccountId());
+                    Optional<AssetTrio> asts = assets.searchMoneyByAccAndCompany(company.getId(), account.getId());
                     asts.ifPresent(ast -> assets.process(ast.a__b(), ast.a__t(), ast.a__f(), BigDecimal.ZERO));
                 }
                 sdf07WasCreated = true;

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

@@ -413,6 +413,14 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                     return Optional.empty();
                 }
             };
+            Function<Statement, String> findCurr = (stmt) -> {
+                Currency currency = currencyImdg.getSingleObjectByID(stmt.getSecurityId());
+                if (currency == null) {
+                    log.warn("failed to find currency for statement.id={} securityId={}", stmt.getId(), stmt.getSecurityId());
+                    return CurrencyCode.RUB.getKey();
+                }
+                return currency.getCurrencyCode();
+            };
             Consumer<StmtCmpAcc> registersUpdate = stmtCmpAcc -> {
                 Statement stmt = stmtCmpAcc.statement();
                 Company cmp = stmtCmpAcc.company();
@@ -429,7 +437,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                         asts = createRegistryIfNeeded.apply(new StmtCmpAcc(stmt, searchResult.getCompany(), searchResult.getAccount()));
                         if (OperationStatus.Executed.equalsByKey(stmt.getOperationStatus())) {
                             Optional<BigDecimal> dmiBalance = dmiService.setOk(searchResult.getTcr().getId(),
-                                    CurrencyCode.RUB.getKey(),
+                                    findCurr.apply(stmt),
                                     sdf57.getDbfId().toString());
                             asts.ifPresent(trio -> {
                                 if (dmiBalance.isPresent() && sessionIsPresent) {
@@ -473,7 +481,7 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                 } else if (OperationStatus.Executed.equalsByKey(stmt.getOperationStatus())) {
                     if (asts.isPresent()) {
                         Optional<BigDecimal> dmiBalance = dmiService.setOk(asts.get().a__t().getTradingClearingRegistryId(),
-                                CurrencyCode.RUB.getKey(),
+                                findCurr.apply(stmt),
                                 sdf57.getDbfId().toString());
                         asts.ifPresent(trio -> {
                             if (dmiBalance.isPresent() && sessionIsPresent) {

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

@@ -8,6 +8,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.clearing.AssetOperationRe
 import ru.spcex.platform.enumeration.CurrencyCode;
 import ru.spcex.platform.enumeration.InOutDirection;
 import ru.spcex.platform.utils.number.BigDecimalUtil;
+import ru.spcex.platform.utils.text.TextUtil;
 
 public class GatewayRequestCreator {
     public static AssetOperationRequest from(Statement stmt,
@@ -30,6 +31,7 @@ public class GatewayRequestCreator {
 
     public static AssetOperationRequest from(Registry rgs, InOutDirection dir) {
         return from(rgs.getId(),
+                rgs.getSecuritySymbol(),
                 null,
                 BigDecimalUtil.safeBD(rgs.getBalance()).abs(),
                 dir,
@@ -39,6 +41,7 @@ public class GatewayRequestCreator {
 
     public static AssetOperationRequest from(PaymentInstruction pmt, String tradingCode, String tcr) {
         return from(pmt.getId(),
+                pmt.getCreditLeg_currencyCode(),
                 null,
                 pmt.getCreditLeg_amount(),
                 InOutDirection.out,
@@ -52,11 +55,22 @@ public class GatewayRequestCreator {
                                              InOutDirection direction,
                                              String tradingCode,
                                              String tcrCode) {
+        return from(entityId, (String) null, sessionId, amount, direction, tradingCode, tcrCode);
+    }
+
+    public static AssetOperationRequest from(Long entityId,
+                                             String currency,
+                                             Long sessionId,
+                                             BigDecimal amount,
+                                             InOutDirection direction,
+                                             String tradingCode,
+                                             String tcrCode) {
+        if (TextUtil.isEmpty(currency)) currency = CurrencyCode.RUB.getKey();
         AssetOperationRequest req = new AssetOperationRequest();
         req.setSessionId(sessionId);
         req.setEntityId(entityId);
         req.setAmount(amount);
-        req.setSecuritySymbol(CurrencyCode.RUB.getKey()); //fixme retrieve security symbol from validator
+        req.setSecuritySymbol(currency);
         req.setTradingCode(tradingCode);
         req.setCode(tcrCode);
         req.setDirection(direction.getKey());

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/payment/PaymentInstructionOutboundService.java

@@ -1,5 +1,10 @@
 package ru.spcex.clearing.service.payment;
 
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Supplier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -33,24 +38,21 @@ import ru.spcex.clearing.service.registry.RegistryManager;
 import ru.spcex.clearing.service.schedule.TradingTimeService;
 import ru.spcex.clearing.service.validation.ValidationStored;
 import ru.spcex.clearing.session.stage.impl.GatewayRequester;
+import static ru.spcex.clearing.session.stage.impl.GatewayRequester.mapError;
 import ru.spcex.clearing.util.security.UserRoleVerification;
-import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.enumeration.CurrencyCode;
+import ru.spcex.platform.enumeration.ObjectType;
+import ru.spcex.platform.enumeration.Priority;
+import ru.spcex.platform.enumeration.TransactionStatus;
+import ru.spcex.platform.enumeration.UserRole;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgId;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumId;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
-import ru.spcex.platform.utils.validation.IValidator;
-
-import java.math.BigDecimal;
-import java.time.Instant;
-import java.util.Optional;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import static ru.spcex.clearing.session.stage.impl.GatewayRequester.mapError;
 import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
+import ru.spcex.platform.utils.validation.IValidator;
 
 @Service
 public class PaymentInstructionOutboundService {
@@ -142,6 +144,7 @@ public class PaymentInstructionOutboundService {
                 .amount(amount)
                 .sessionId(null)
                 .purpose(purpose)
+                .currency(accCred.getCurrency())
                 .build();
         BankAccount bnkAcc = bnkAccImdg.getFirstObjectBySQL("accountId = %d".formatted(accDeb.getId()));
         if (bnkAcc != null) {

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/registry/AssetTBFProcessing.java

@@ -1,5 +1,12 @@
 package ru.spcex.clearing.service.registry;
 
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -10,38 +17,37 @@ import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.service.AssetTrio;
 import ru.spcex.clearing.session.stage.util.RegistryUtil;
-import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.enumeration.BalanceDimension;
+import ru.spcex.platform.enumeration.RegistryDesignation;
+import ru.spcex.platform.enumeration.RegistryInstrumentType;
+import ru.spcex.platform.enumeration.RegistryStatus;
+import ru.spcex.platform.enumeration.RegistryTradingParams;
+import static ru.spcex.platform.enumeration.RegistryTradingParams.*;
+import ru.spcex.platform.enumeration.RegistryUnit;
 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.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
-
-import java.math.BigDecimal;
-import java.time.Instant;
-import java.util.Collection;
-import java.util.Optional;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import static ru.spcex.platform.enumeration.RegistryTradingParams.*;
 import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
 
 @Service
 public class AssetTBFProcessing {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final Imdg<Registry> rgsImdg;
+    private final Imdg<Account> accImdg;
     private final RegistryManager rgsMng;
 
     @Autowired
     public AssetTBFProcessing(ImdgProvider imdgProvider, RegistryManager rgsMng) {
         this.rgsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        this.accImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.rgsMng = rgsMng;
     }
 
-    public AssetTBFProcessing(Imdg<Registry> rgsImdg) {
+    public AssetTBFProcessing(Imdg<Registry> rgsImdg, Imdg<Account> accImdg) {
         this.rgsImdg = rgsImdg;
+        this.accImdg = accImdg;
         this.rgsMng = new RegistryManager(rgsImdg);
     }
 
@@ -271,12 +277,17 @@ public class AssetTBFProcessing {
     }
 
     public Optional<AssetTrio> searchMoneyByAccAndCompany(Long companyId, Long accountId) {
+        Account account = accImdg.getSingleObjectByID(accountId);
+        if (account == null) {
+            log.error("company.id={}, account.id={} - account not found", companyId, accountId);
+            return Optional.empty();
+        }
         ImdgPredicateBuilder pb = rgsImdg.predicateBuilder();
         Function<RegistryTradingParams, ImdgPredicate> prdct = rgsCode -> pb.and(
                 pb.sql(RegistryCodeSqlBuilder.getInstance(rgsCode).build()),
                 pb.equals("companyId", companyId),
                 pb.equals("accountId", accountId),
-                pb.equals("securitySymbol", CurrencyCode.RUB.getKey())
+                pb.equals("securitySymbol", account.getCurrency())
         );
         Registry amf = rgsImdg.getFirstObjectByPredicate(prdct.apply(AM_F));
         Registry amb = rgsImdg.getFirstObjectByPredicate(prdct.apply(AM_B));

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

@@ -1,5 +1,7 @@
-package ru.spcex.platform.imdg.validation.rule;
+package ru.spcex.clearing.service.validation;
 
+import java.util.Optional;
+import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.AccountType;
@@ -13,8 +15,6 @@ import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IErrorEnumId;
 import ru.spcex.platform.utils.validation.IValidationRule;
 
-import java.util.Optional;
-
 /**
  * В рексевте необходим интерфейс WithId
  */
@@ -27,11 +27,14 @@ public class AnltAccLoad implements IValidationRule<ImdgValidationContext<Object
 
     @Override
     public Optional<EnumMessage> validate(ImdgValidationContext<Object> context) {
+        //если захотим где-то еще использовать, нужно сделать Registry implements WithCurrency
+        Registry rgs = context.getStoredObject(Stored.PresentById);
         Imdg<SpcexObjectBase> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, SpcexObjectBase.class);
         ImdgPredicateBuilder pb = accImdg.predicateBuilder();
         ImdgPredicate prdct = pb.and(
                 pb.equals("companyId", Sender.One.getId()),
-                pb.equals("accountType", AccountType.Anlt.getKey())
+                pb.equals("accountType", AccountType.Anlt.getKey()),
+                pb.equals("currency", rgs.getSecuritySymbol())
         );
         Object anltAcc = accImdg.getSingleObjectByPredicate(prdct);
         if (anltAcc == null) {

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

@@ -1,17 +1,22 @@
 package ru.spcex.clearing.service.validation;
 
+import java.math.BigDecimal;
+import java.util.Optional;
 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.registry.Registry;
 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.clearing.platform.messaging.domain.cud.registry.IdentificationFundsRequest;
 import ru.spcex.clearing.service.AnltSearcher;
 import ru.spcex.clearing.service.AssetTrio;
+import ru.spcex.clearing.service.TcrSearcher;
 import ru.spcex.clearing.service.registry.AssetTBFProcessing;
+import static ru.spcex.clearing.service.registry.RegistryManager.equalsByCode;
 import ru.spcex.platform.enumeration.AccountType;
 import ru.spcex.platform.enumeration.RegistryTradingParams;
 import ru.spcex.platform.enumeration.ServiceStatus;
@@ -21,13 +26,8 @@ import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.imdg.validation.Stored;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
-import ru.spcex.platform.utils.validation.IValidationRule;
-
-import java.math.BigDecimal;
-import java.util.Optional;
-
-import static ru.spcex.clearing.service.registry.RegistryManager.equalsByCode;
 import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
+import ru.spcex.platform.utils.validation.IValidationRule;
 
 public enum IdentificationFundsValidationRule implements IValidationRule<ImdgValidationContext<IdentificationFundsRequest>> {
     Fields() {
@@ -77,9 +77,14 @@ public enum IdentificationFundsValidationRule implements IValidationRule<ImdgVal
     TcrCheck() {
         @Override
         public Optional<EnumMessage> validate(ImdgValidationContext<IdentificationFundsRequest> context) {
+            Registry rgs = context.getStoredObject(Stored.PresentById);
             IdentificationFundsRequest validatedObject = context.getValidatedObject();
 
             Imdg<TradingClearingRegistry> tcrImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+            Imdg<TradingClearingRegistryList> tcrListImdg = context.obtainMap(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class);
+            Imdg<Account> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            Imdg<Company> cmpImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
+
             TradingClearingRegistry tcr = tcrImdg.getSingleObjectByID(validatedObject.getTradingClearingRegistryId());
             if (tcr == null) {
                 return of(ClearingError.TCRegistryNotFound, validatedObject.getTradingClearingRegistryId());
@@ -92,16 +97,20 @@ public enum IdentificationFundsValidationRule implements IValidationRule<ImdgVal
                 return of(ClearingError.AccountNotFoundB, "null"); //mb other error
             }
 
-            Imdg<Account> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            TcrSearcher tcrSearcher = new TcrSearcher(tcrImdg,
-            Account acc = accImdg.getSingleObjectByID(tcr.getMoneyAccountId());
+                tcrListImdg,
-            if (acc == null) {
+                cmpImdg,
-                return of(ClearingError.AccountNotFoundB, tcr.getMoneyAccountId());
+                accImdg);
+            Optional<Account> accF = tcrSearcher.searchByTcr(tcr.getId(), rgs.getSecuritySymbol());
+            if (accF.isEmpty()) {
+                return of(ClearingError.AccountNotFoundB, "<by TCR.id=%d for currency %s>"
+                    .formatted(tcr.getId(), rgs.getSecuritySymbol()));
             }
+            Account acc = accF.get();
             if (!AccountType.Info.equalsByKey(acc.getAccountType())) {
                 return of(ClearingError.AccountWrongType, acc.getAccountType());
             }
 
-            Imdg<Company> cmpImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
             Company company = cmpImdg.getSingleObjectByID(tcr.getCompanyId());
             if (company == null) {
                 return of(ClearingError.CompanyNotFoundB, tcr.getCompanyId());
@@ -120,7 +129,8 @@ public enum IdentificationFundsValidationRule implements IValidationRule<ImdgVal
                 return of(ClearingError.RecordNotFound, "AM*T");
             }
             Imdg<Registry> rgsImdg = context.obtainMap(IMDGDistributedNames.Map_Registry, Registry.class);
-            AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg);
+            Imdg<Account> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg, accImdg);
             Optional<AssetTrio> assetTrio = assets.searchMoneyByAccAndCompany(tcrSearch.getCompany().getId(), tcrSearch.getAccount().getId());
             if (assetTrio.isEmpty()) {
                 return of(ClearingError.RecordNotFound, "AM*T");

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

@@ -1,7 +1,9 @@
 package ru.spcex.clearing.service.validation;
 
+import java.util.Optional;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.payment.PaymentInstruction;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
@@ -17,8 +19,6 @@ import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.validation.IValidationRule;
 
-import java.util.Optional;
-
 public enum Sdf55ValidationRule implements IValidationRule<ImdgValidationContext<StatementRequest>> {
     Fields() {
         @Override
@@ -96,11 +96,12 @@ public enum Sdf55ValidationRule implements IValidationRule<ImdgValidationContext
         @Override
         public Optional<EnumMessage> validate(ImdgValidationContext<StatementRequest> context) {
             Imdg<Registry> rgsImdg = context.obtainMap(IMDGDistributedNames.Map_Registry, Registry.class);
+            Imdg<Account> accImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
             PaymentInstruction pmt = context.getStoredObject(ValidationStored.Sdf55PaymentInstruction);
             Long accCredId = pmt.getCreditLeg_accountId();
             Long addresseeId = pmt.getSenderId();
 
-            AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg);
+            AssetTBFProcessing assets = new AssetTBFProcessing(rgsImdg, accImdg);
             Optional<AssetTrio> assetTrio = assets.searchMoneyByAccAndCompany(addresseeId, accCredId);
             if (assetTrio.isEmpty()) {
                 return of(ClearingError.RecordNotFound, "AM*F/AM*B/AM*T");