session RequirementsAndObligationCreation (2 step) optimization

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/IRegistryBuilder.java

@@ -9,32 +9,36 @@ import ru.clearing.classes.statics.data.misc.Currency;
 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.security.CurrencyPairSecurity;
 import ru.clearing.classes.statics.data.security.Security;
 import ru.clearing.platform.dictionary.CurrencyPairDictionary;
+import ru.spcex.clearing.service.TcrSearcher;
 import ru.spcex.platform.enumeration.RegistryDesignation;
+import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2ById;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2ByIdAndString;
 
 public interface IRegistryBuilder {
 
-    IRegistryBuilder imdg(ImdgProvider imdgProvider);
+    @Deprecated
+    default IRegistryBuilder imdg(ImdgProvider imdgProvider) {return this;}
+    default IRegistryBuilder cmpImdg(Imdg<Company> cmpImdg) {return this;}
+    default IRegistryBuilder tcrImdg(Imdg<TradingClearingRegistry> tcrImdg) {return this;}
+    default IRegistryBuilder accImdg(Imdg<Account> accImdg) {return this;}
+    default IRegistryBuilder ssnImdg(Imdg<Session> ssnImdg) {return this;}
+    default IRegistryBuilder clAccImdg(Imdg<ClearingAccount> clAccImdg) {return this;}
+    default IRegistryBuilder dpAccImdg(Imdg<DepoAccount> dpAccImdg) {return this;}
+    default IRegistryBuilder currPairSecImdg(Imdg<CurrencyPairSecurity> currPairSecImdg) {return this;}
+    default IRegistryBuilder currPairDictImdg(Imdg<CurrencyPairDictionary> currPairDictImdg) {return this;}
+    default IRegistryBuilder currImdg(Imdg<Currency> currImdg) {return this;}
+    default IRegistryBuilder tcrSearcher(TcrSearcher tcrSearcher) {return this;}
+    default IRegistryBuilder secSelector(SecuritySelector<Security> secSelector) {return this;}
     IRegistryBuilder exec(ExecutionCommon exec);
     IRegistryBuilder registryDesignation(RegistryDesignation registryDesignation);
     IRegistryBuilder returnDeposit(boolean returnDeposit);
     Registry build();
-    default IRegistryBuilder cmpCash(CashV2<Long, Company> cmpCash) {return this;}
-    default IRegistryBuilder tcrCash(CashV2<Long, TradingClearingRegistry> tcrCash) {return this;}//CashV2<Long, TradingClearingRegistry> tcrCash;
-    default IRegistryBuilder accCash(CashV2<Long, Account> accCash) {return this;}//CashV2<Long, Account> accCash;
     default IRegistryBuilder dpAccCash(CashV2<Long, DepoAccount> dpAccCash) {return this;}//CashV2<Long, DepoAccount> dpAccCash;
-    default IRegistryBuilder scrtCash(CashV2ById<Security> scrtCash) {return this;}//CashV2<Long, Security> scrtCash;
     default IRegistryBuilder currCash(CashV2<String, Currency> currCash) {return this;}//CashV2<String, Currency> currCash;
     default IRegistryBuilder clrAccCash(CashV2<Long, ClearingAccount> clrAccCash) {return this;}//CashV2<Long, ClearingAccount> clrAccCash;
-    default IRegistryBuilder ssnCash(CashV2<Long, Session> ssnCash) {return this;}//CashV2<Long, ClearingAccount> clrAccCash;
-    default IRegistryBuilder tcrListCash(CashV2ByIdAndString<TradingClearingRegistryList> tcrListCash) {return this;}
-    default IRegistryBuilder currPairCash(CashV2<Long, CurrencyPairSecurity> currPairCash) {return this;}
-    default IRegistryBuilder currPairDictCash(CashV2<Long, CurrencyPairDictionary> currPairDictCash) {return this;}
 }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RegistryCurrBuilder.java

@@ -12,12 +12,10 @@ import ru.clearing.classes.statics.data.misc.Currency;
 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.security.CurrencyPairSecurity;
 import ru.clearing.platform.dictionary.CurrencyPairDictionary;
 import ru.spcex.clearing.component.predicate.cash.account.AccountIdCashingPredicate;
 import ru.spcex.clearing.component.predicate.cash.currency.CurrencyCodePredicate;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.service.TcrSearcher;
 import ru.spcex.clearing.session.stage.util.RegistryUtil;
 import ru.spcex.platform.classes.base.interfaces.ExecutionType;
@@ -34,20 +32,11 @@ import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.enumeration.Section;
 import ru.spcex.platform.enumeration.Side;
 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.iml.hazelcast.adapter.CashV2;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2ByIdAndString;
 
 public class RegistryCurrBuilder implements IRegistryBuilder {
-    private CashV2<Long, Company> cmpCash;
-    private CashV2<Long, Session> ssnCash;
-    private CashV2<Long, TradingClearingRegistry> tcrCash;
-    private CashV2ByIdAndString<TradingClearingRegistryList> tcrListCash;
-    private CashV2<Long, Account> accCash;
     private CashV2<String, Currency> currCash;
-    private CashV2<Long, CurrencyPairSecurity> currPairCash;
-    private CashV2<Long, CurrencyPairDictionary> currPairDictCash;
     private CashV2<Long, ClearingAccount> clrAccCash;
 
     private Imdg<Company> companyImdg;
@@ -69,21 +58,43 @@ public class RegistryCurrBuilder implements IRegistryBuilder {
         return new RegistryCurrBuilder();
     }
 
-    @Override
+    public IRegistryBuilder cmpImdg(Imdg<Company> cmpImdg) {
-    public RegistryCurrBuilder imdg(ImdgProvider imdgProvider) {
+        this.companyImdg = cmpImdg;
-        this.companyImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Company, Company.class, cmpCash);
+        return this;
-        this.tradingClearingRegistryImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class, tcrCash);
+    }
-        Imdg<TradingClearingRegistryList> tcrListImdg = imdgProvider.getCashingImdg(
+
-            IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class, null
+    public IRegistryBuilder tcrImdg(Imdg<TradingClearingRegistry> tcrImdg) {
-        );
+        this.tradingClearingRegistryImdg = tcrImdg;
-        Imdg<Account> accountImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Account, Account.class, accCash);
+        return this;
-        this.sessionImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Session, Session.class, ssnCash);
+    }
-        this.clearingAccountImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class, null);
+
-        this.currPairSecImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class, currPairCash);
+    public IRegistryBuilder ssnImdg(Imdg<Session> ssnImdg) {
-        this.currPairDictImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class, currPairDictCash);
+        this.sessionImdg = ssnImdg;
-        this.currencyImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Currency, Currency.class, null);
+        return this;
-        this.tcrSearcher = new TcrSearcher(tradingClearingRegistryImdg, tcrListImdg, companyImdg, accountImdg);
+    }
-        this.tcrSearcher.setTcrListCash(tcrListCash);
+
+    public IRegistryBuilder clAccImdg(Imdg<ClearingAccount> clAccImdg) {
+        this.clearingAccountImdg = clAccImdg;
+        return this;
+    }
+
+    public IRegistryBuilder currPairSecImdg(Imdg<CurrencyPairSecurity> currPairSecImdg) {
+        this.currPairSecImdg = currPairSecImdg;
+        return this;
+    }
+
+    public IRegistryBuilder currPairDictImdg(Imdg<CurrencyPairDictionary> currPairDictImdg) {
+        this.currPairDictImdg = currPairDictImdg;
+        return this;
+    }
+
+    public IRegistryBuilder currImdg(Imdg<Currency> currImdg) {
+        this.currencyImdg = currImdg;
+        return this;
+    }
+
+    public IRegistryBuilder tcrSearcher(TcrSearcher tcrSearcher) {
+        this.tcrSearcher = tcrSearcher;
         return this;
     }
 
@@ -252,24 +263,6 @@ public class RegistryCurrBuilder implements IRegistryBuilder {
         return capacityByAccount;
     }
 
-    @Override
-    public IRegistryBuilder cmpCash(CashV2<Long, Company> cmpCash) {
-        this.cmpCash = cmpCash;
-        return this;
-    }
-
-    @Override
-    public IRegistryBuilder tcrCash(CashV2<Long, TradingClearingRegistry> tcrCash) {
-        this.tcrCash = tcrCash;
-        return this;
-    }
-
-    @Override
-    public IRegistryBuilder accCash(CashV2<Long, Account> accCash) {
-        this.accCash = accCash;
-        return this;
-    }
-
     @Override
     public IRegistryBuilder currCash(CashV2<String, Currency> currCash) {
         this.currCash = currCash;
@@ -281,28 +274,4 @@ public class RegistryCurrBuilder implements IRegistryBuilder {
         this.clrAccCash = clrAccCash;
         return this;
     }
-
-    @Override
-    public IRegistryBuilder ssnCash(CashV2<Long, Session> ssnCash) {
-        this.ssnCash = ssnCash;
-        return this;
-    }
-
-    @Override
-    public IRegistryBuilder tcrListCash(CashV2ByIdAndString<TradingClearingRegistryList> tcrListCash) {
-        this.tcrListCash = tcrListCash;
-        return this;
-    }
-
-    @Override
-    public IRegistryBuilder currPairCash(CashV2<Long, CurrencyPairSecurity> currPairCash) {
-        this.currPairCash = currPairCash;
-        return this;
-    }
-
-    @Override
-    public IRegistryBuilder currPairDictCash(CashV2<Long, CurrencyPairDictionary> currPairDictCash) {
-        this.currPairDictCash = currPairDictCash;
-        return this;
-    }
 }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RegistryFondBuilder.java

@@ -7,19 +7,16 @@ import java.time.LocalDate;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.ClearingAccount;
 import ru.clearing.classes.statics.data.account.DepoAccount;
-import ru.clearing.classes.statics.data.account.InformationAccount;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.execution.ExecutionCommon;
 import ru.clearing.classes.statics.data.execution.ExecutionFond;
 import ru.clearing.classes.statics.data.misc.Currency;
-import ru.clearing.classes.statics.data.misc.Market;
 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.security.Security;
 import ru.spcex.clearing.component.predicate.cash.account.AccountIdCashingPredicate;
 import ru.spcex.clearing.component.predicate.cash.currency.CurrencyCodePredicate;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.session.stage.util.RegistryUtil;
 import ru.spcex.platform.classes.base.interfaces.ExecutionType;
 import ru.spcex.platform.enumeration.AccountType;
@@ -35,32 +32,22 @@ import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.enumeration.Section;
 import ru.spcex.platform.enumeration.Side;
 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.specific.SecuritySelector;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2ById;
 import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD;
 
 public class RegistryFondBuilder implements IRegistryBuilder {
-    CashV2<Long, Company> cmpCash;
-    CashV2<Long, Session> ssnCash;
-    CashV2<Long, TradingClearingRegistry> tcrCash;
-    CashV2<Long, Account> accCash;
     CashV2<Long, DepoAccount> dpAccCash;
-    CashV2ById<Security> scrtCash;
     CashV2<String, Currency> currCash;
     CashV2<Long, ClearingAccount> clrAccCash;
-
+    private Imdg<Company> cmpImdg;
-    private Imdg<Company> companyImdg;
+    private Imdg<TradingClearingRegistry> tcrImdg;
-    private Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
+    private Imdg<Account> accImdg;
-    private Imdg<Account> accountImdg;
+    private Imdg<Session> ssnImdg;
-    private Imdg<Market> marketImdg;
+    private Imdg<ClearingAccount> clAccImdg;
-    private Imdg<Session> sessionImdg;
+    private Imdg<DepoAccount> dpAccImdg;
-    private Imdg<ClearingAccount> clearingAccountImdg;
+    private Imdg<Currency> currImdg;
-    private Imdg<InformationAccount> informationAccountImdg;
-    private Imdg<DepoAccount> depoAccountImdg;
-    private Imdg<Currency> currencyImdg;
     private SecuritySelector<Security> scrSlctr;
     private ExecutionCommon exec;
     private RegistryDesignation regDsgn;
@@ -73,47 +60,63 @@ public class RegistryFondBuilder implements IRegistryBuilder {
     }
 
     @Override
-    public RegistryFondBuilder imdg(ImdgProvider imdgProvider) {
+    public IRegistryBuilder cmpImdg(Imdg<Company> cmpImdg) {
-        this.companyImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Company, Company.class, cmpCash);
+        this.cmpImdg = cmpImdg;
-        this.tradingClearingRegistryImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class, tcrCash);
-        this.accountImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Account, Account.class, accCash);
-        this.sessionImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Session, Session.class, ssnCash);
-        this.clearingAccountImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class, null);
-        this.depoAccountImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class, null);
-        this.currencyImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Currency, Currency.class, null);
-        this.scrSlctr = new SecuritySelector<>(imdgProvider, Security.class);
         return this;
     }
 
     @Override
-    public IRegistryBuilder cmpCash(CashV2<Long, Company> cmpCash) {
+    public IRegistryBuilder tcrImdg(Imdg<TradingClearingRegistry> tcrImdg) {
-        this.cmpCash = cmpCash;
+        this.tcrImdg = tcrImdg;
         return this;
     }
 
     @Override
-    public IRegistryBuilder tcrCash(CashV2<Long, TradingClearingRegistry> tcrCash) {
+    public IRegistryBuilder accImdg(Imdg<Account> accImdg) {
-        this.tcrCash = tcrCash;
+        this.accImdg = accImdg;
         return this;
     }
 
     @Override
-    public IRegistryBuilder accCash(CashV2<Long, Account> accCash) {
+    public IRegistryBuilder ssnImdg(Imdg<Session> ssnImdg) {
-        this.accCash = accCash;
+        this.ssnImdg = ssnImdg;
         return this;
     }
 
+    @Override
+    public IRegistryBuilder clAccImdg(Imdg<ClearingAccount> clAccImdg) {
+        this.clAccImdg = clAccImdg;
+        return this;
+    }
+
+    @Override
+    public IRegistryBuilder dpAccImdg(Imdg<DepoAccount> dpAccImdg) {
+        this.dpAccImdg = dpAccImdg;
+        return this;
+    }
+
+    @Override
+    public IRegistryBuilder currImdg(Imdg<Currency> currImdg) {
+        this.currImdg = currImdg;
+        return this;
+    }
+
+    @Override
+    public IRegistryBuilder secSelector(SecuritySelector<Security> secSelector) {
+        this.scrSlctr = secSelector;
+        return this;
+    }
+
+
+
+
     @Override
     public IRegistryBuilder dpAccCash(CashV2<Long, DepoAccount> dpAccCash) {
         this.dpAccCash = dpAccCash;
         return this;
     }
 
-    @Override
+
-    public IRegistryBuilder scrtCash(CashV2ById<Security> scrtCash) {
-        this.scrtCash = scrtCash;
-        return this;
-    }
 
     @Override
     public IRegistryBuilder currCash(CashV2<String, Currency> currCash) {
@@ -127,11 +130,6 @@ public class RegistryFondBuilder implements IRegistryBuilder {
         return this;
     }
 
-    @Override
-    public IRegistryBuilder ssnCash(CashV2<Long, Session> ssnCash) {
-        this.ssnCash = ssnCash;
-        return this;
-    }
 
     @Override
     public RegistryFondBuilder exec(ExecutionCommon exec) {
@@ -172,15 +170,15 @@ public class RegistryFondBuilder implements IRegistryBuilder {
             isMoney = true;
             reg.setAccountId(tcr.getMoneyAccountId());
             if (tcr.getMoneyAccountId() != null) {
-                account = accountImdg.getSingleObjectByID(tcr.getMoneyAccountId());
+                account = accImdg.getSingleObjectByID(tcr.getMoneyAccountId());
                 capacityByAccount = defineCapacityByAccountType(account.getAccountType(), tcr.getMoneyAccountId());
             }
             reg.setRegistryInstrumentType(RegistryInstrumentType.M.getKey());
             reg.setBalanceDimension(BalanceDimension.MONY.getKey()); //fixme add second leg code branch
             ImdgPredicate currPrdct = CurrencyCodePredicate
                 .getPredicate(exec.getSettlementCurrency())
-                .cashed(currencyImdg.predicateBuilder(), currCash);
+                .cashed(currImdg.predicateBuilder(), currCash);
-            Currency currency = currencyImdg.getFirstObjectByPredicate(currPrdct);
+            Currency currency = currImdg.getFirstObjectByPredicate(currPrdct);
             reg.setSecurityId(currency.getId());
             reg.setSecuritySymbol(currency.getCurrencyCode());
         } else if ((regDsgn.equals(RegistryDesignation.T) && side.isBuy()) || (regDsgn.equals(RegistryDesignation.O) && side.isSell())) {
@@ -188,11 +186,11 @@ public class RegistryFondBuilder implements IRegistryBuilder {
             reg.setAccountId(tcr.getDepoAccountId());
             DepoAccount depoAccount = null;
             if (tcr.getDepoAccountId() != null) {
-                account = accountImdg.getSingleObjectByID(tcr.getDepoAccountId());
+                account = accImdg.getSingleObjectByID(tcr.getDepoAccountId());
                 ImdgPredicate depAccPrdct = AccountIdCashingPredicate
                     .getPredicate(tcr.getDepoAccountId())
-                    .cashed(depoAccountImdg.predicateBuilder(), dpAccCash);
+                    .cashed(dpAccImdg.predicateBuilder(), dpAccCash);
-                depoAccount = depoAccountImdg.getFirstObjectByPredicate(depAccPrdct);
+                depoAccount = dpAccImdg.getFirstObjectByPredicate(depAccPrdct);
             }
             if (depoAccount != null) {
                 capacityByAccount = depoAccount.getDepoAccountType();
@@ -218,9 +216,7 @@ public class RegistryFondBuilder implements IRegistryBuilder {
         reg.setRegistryStatus(RegistryStatus.PROC.getKey());
         ExecutionFond execFond = (ExecutionFond) this.exec;
         if (isMoney) {
-            Security security = scrtCash.getOrFind(
+            Security security = scrSlctr.selectSecurityById(execFond.getSecurityId());
-                execFond.getSecurityId(), () -> scrSlctr.selectSecurityById(execFond.getSecurityId())
-            ).orElse(null);
             if (InstrumentType.BOND.equalsByKey(security.getInstrumentType())) {
                 BigDecimal stlAmt = safeBD(execFond.getSettlementAmount());
                 BigDecimal intAmt = safeBD(execFond.getInterestAmount());
@@ -253,16 +249,16 @@ public class RegistryFondBuilder implements IRegistryBuilder {
 
     //можно передать из стейджа
     private String sessionType() {
-        Session session = sessionImdg.getSingleObjectByID(exec.getSessionId());
+        Session session = ssnImdg.getSingleObjectByID(exec.getSessionId());
         return session.getSessionType();
     }
 
     private Company searchCompany() {
-        return companyImdg.getSingleObjectByID(exec.getCompanyId());
+        return cmpImdg.getSingleObjectByID(exec.getCompanyId());
     }
 
     private TradingClearingRegistry searchTradingClearingRegistry() {
-        return tradingClearingRegistryImdg.getSingleObjectByID(exec.getTradingClearingRegistryId());
+        return tcrImdg.getSingleObjectByID(exec.getTradingClearingRegistryId());
     }
 
     private static ISide getSide(ExecutionCommon exec) {
@@ -280,8 +276,8 @@ public class RegistryFondBuilder implements IRegistryBuilder {
         if (AccountType.Clrn.equalsByKey(accountType)) {
             ImdgPredicate prdct = AccountIdCashingPredicate
                 .getPredicate(moneyAccountId)
-                .cashed(clearingAccountImdg.predicateBuilder(), clrAccCash);
+                .cashed(clAccImdg.predicateBuilder(), clrAccCash);
-            ClearingAccount clearingAccount = clearingAccountImdg.getFirstObjectByPredicate(prdct);
+            ClearingAccount clearingAccount = clAccImdg.getFirstObjectByPredicate(prdct);
             if (clearingAccount != null) {
                 capacityByAccount = clearingAccount.getClearingAccountType();
             }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RequirementsAndObligationCreation.java

@@ -23,15 +23,19 @@ import ru.clearing.classes.statics.data.execution.ExecutionCommon;
 import ru.clearing.classes.statics.data.execution.ExecutionCurrency;
 import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
 import ru.clearing.classes.statics.data.execution.ExecutionFond;
+import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
 import ru.clearing.classes.statics.data.misc.Currency;
 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.security.CurrencyPairSecurity;
+import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
 import ru.clearing.classes.statics.data.security.Security;
 import ru.clearing.platform.dictionary.CurrencyPairDictionary;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.service.TcrSearcher;
 import ru.spcex.clearing.session.stage.ISessionStage;
 import ru.spcex.clearing.session.stage.StageResult;
 import ru.spcex.clearing.session.stage.Task;
@@ -54,6 +58,7 @@ 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 ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashCloser;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2ById;
@@ -73,6 +78,21 @@ public class RequirementsAndObligationCreation implements ISessionStage {
     private final ImdgProvider imdgProvider;
     protected final RequirementsAndObligationCreationCash cash;
 
+    private final Imdg<Company> cmpImdg;
+    private final Imdg<TradingClearingRegistry> tcrImdg;
+    private final Imdg<Account> accImdg;
+    private final Imdg<Session> ssnImdg;
+    private final Imdg<ClearingAccount> clAccImdg;
+    private final Imdg<DepoAccount> dpAccImdg;
+    private final Imdg<CurrencyPairSecurity> currPairSecImdg;
+    private final Imdg<FixedIncomeSecurity> fixIncSecImdg;
+    private final Imdg<MoneyMarketSecurity> monMrktSecImdg;
+    private final Imdg<EquitySecurity> eqtySecImdg;
+    private final Imdg<CurrencyPairDictionary> currPairDictImdg;
+    private final Imdg<Currency> currImdg;
+    private final TcrSearcher tcrSearcher;
+    private final SecuritySelector<Security> secSelector;
+
 
     @Autowired
     public RequirementsAndObligationCreation(ImdgProvider imdgProvider) {
@@ -80,6 +100,33 @@ public class RequirementsAndObligationCreation implements ISessionStage {
         this.idGen = imdgProvider.getImdgIdGenerator();
         this.imdgProvider = imdgProvider;
         this.cash = new RequirementsAndObligationCreationCash();
+        this.cmpImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Company, Company.class, cash.cmpCash);
+        this.tcrImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class, cash.tcrCash);
+        Imdg<TradingClearingRegistryList> tcrListImdg = imdgProvider.getCashingImdg(
+            IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class, null
+        );
+        this.accImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Account, Account.class, cash.accCash);
+        this.ssnImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Session, Session.class, cash.ssnCash);
+        this.clAccImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class, null);
+        this.dpAccImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class, null);
+        this.currPairSecImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class, cash.currPairCash);
+        this.fixIncSecImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class, cash.fixIncSecCash);
+        this.monMrktSecImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class, cash.monMrktSecCash);
+        this.eqtySecImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class, cash.eqtySecCash);
+        this.currPairDictImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class, cash.currPairDictCash);
+        this.currImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Currency, Currency.class, null);
+
+
+        this.tcrSearcher = new TcrSearcher(tcrImdg, tcrListImdg, cmpImdg, accImdg);
+        this.tcrSearcher.setTcrListCash(cash.tcrListCash);
+        this.secSelector = new SecuritySelector<>(castSecImdg(fixIncSecImdg),
+            castSecImdg(monMrktSecImdg),
+            castSecImdg(eqtySecImdg),
+            castSecImdg(currPairSecImdg));
+    }
+
+    private static <T extends Security> Imdg<Security> castSecImdg(Imdg<T> m) {
+        return (Imdg<Security>) m;
     }
 
     @SuppressWarnings("unchecked")
@@ -181,16 +228,21 @@ public class RequirementsAndObligationCreation implements ISessionStage {
                                 IRegistryBuilder registryBuilder = defineBuilderByExecType(partyExec.type());
                                 Registry newRegister = registryBuilder
                                         //cashes
-                                        .cmpCash(cash.cmpCash)
-                                        .tcrCash(cash.tcrCash)
-                                        .accCash(cash.accCash)
                                         .dpAccCash(cash.dpAccCash)
-                                        .scrtCash(cash.scrtCash)
+                                        .currCash(cash.currCash)
-                                        .currCash(cash.currCash).currPairCash(cash.currPairCash).currPairDictCash(cash.currPairDictCash)
-                                        .tcrListCash(cash.tcrListCash)
                                         .clrAccCash(cash.clrAccCash)
-                                        .ssnCash(cash.ssnCash)
+                                        //imdg
-                                        //------
+                                        .cmpImdg(cmpImdg)
+                                        .tcrImdg(tcrImdg)
+                                        .accImdg(accImdg)
+                                        .ssnImdg(ssnImdg)
+                                        .clAccImdg(clAccImdg)
+                                        .dpAccImdg(dpAccImdg)
+                                        .currPairSecImdg(currPairSecImdg)
+                                        .currPairDictImdg(currPairDictImdg)
+                                        .currImdg(currImdg)
+                                        .tcrSearcher(tcrSearcher)
+                                        .secSelector(secSelector)
                                         .imdg(imdgProvider)
                                         .exec(exec)
                                         .registryDesignation(regDsgn)
@@ -377,11 +429,13 @@ public class RequirementsAndObligationCreation implements ISessionStage {
         protected final CashV2<Long, TradingClearingRegistry> tcrCash;
         protected final CashV2<Long, Account> accCash;
         protected final CashV2<Long, DepoAccount> dpAccCash;
-        protected final CashV2ById<Security> scrtCash;
         protected final CashV2<String, Currency> currCash;
         protected final CashV2<Long, ClearingAccount> clrAccCash;
         protected final CashV2<Long, Session> ssnCash;
         protected final CashV2<Long, CurrencyPairSecurity> currPairCash;
+        protected final CashV2<Long, FixedIncomeSecurity> fixIncSecCash;
+        protected final CashV2<Long, MoneyMarketSecurity> monMrktSecCash;
+        protected final CashV2<Long, EquitySecurity> eqtySecCash;
         protected final CashV2<Long, CurrencyPairDictionary> currPairDictCash;
         protected final CashV2ByIdAndString<TradingClearingRegistryList> tcrListCash;
 
@@ -391,11 +445,13 @@ public class RequirementsAndObligationCreation implements ISessionStage {
             tcrCash = add(new CashV2ById<>("tcrCash"));
             accCash = add(new CashV2ById<>("accCash"));
             dpAccCash = add(new CashV2ById<>("dpAccCash"));
-            scrtCash = add(new CashV2ById<>("scrtCash"));
             currCash = add(new CashV2ByString<>("currCash", Currency::getCurrencyCode));
             clrAccCash = add(new CashV2ById<>("clrAccCash"));
             ssnCash = add(new CashV2ById<>("ssnCash"));
             currPairCash = add(new CashV2ById<>("currPairCash"));
+            fixIncSecCash = add(new CashV2ById<>("fixIncSecCash"));
+            monMrktSecCash = add(new CashV2ById<>("monMrktSecCash"));
+            eqtySecCash = add(new CashV2ById<>("eqtySecCash"));
             currPairDictCash = add(new CashV2ById<>("currPairDictCash"));
             tcrListCash = add(new CashV2ByIdAndString<>("tcrListCash", tcrList -> new CashV2ByIdAndString.CustomKey(tcrList.getTradingClearingRegistryId(), tcrList.getCurrency())));
         }