currency session cashing

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/component/predicate/cash/tcr/TcrListByTcrIdAndCurrencyPredicate.java

@@ -0,0 +1,33 @@
+package ru.spcex.clearing.component.predicate.cash.tcr;
+
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
+import ru.spcex.platform.enumeration.Status;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2ByIdAndString;
+
+public class TcrListByTcrIdAndCurrencyPredicate {
+    public static TcrListByTcrIdAndCurrencyPredicate getPredicate(Long tcrId, String curCde) {
+        return new TcrListByTcrIdAndCurrencyPredicate(tcrId, curCde);
+    }
+
+    private final Long tcrId;
+    private final String cur;
+
+    private TcrListByTcrIdAndCurrencyPredicate(Long tcrId, String cur) {
+        this.tcrId = tcrId;
+        this.cur = cur;
+    }
+
+    public ImdgPredicate cashed(ImdgPredicateBuilder pb, CashV2ByIdAndString<TradingClearingRegistryList> cash) {
+        ImdgPredicate prdct = pb.and(
+            pb.equals("tradingClearingRegistryId", tcrId),
+            pb.equals("currency", cur),
+            pb.equals("status", Status.Active.getKey())
+        );
+        if (cash != null) {
+            CashV2ByIdAndString.CustomKey key = new CashV2ByIdAndString.CustomKey(tcrId, cur);
+            return pb.cashed(prdct, cash, key);
+        } else return prdct;
+    }
+}

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

@@ -9,15 +9,16 @@ 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.component.predicate.cash.tcr.TcrListByTcrIdAndCurrencyPredicate;
 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.enumeration.Status;
 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.iml.hazelcast.adapter.CashV2ByIdAndString;
 
 @Component
 public class TcrSearcher {
@@ -26,7 +27,11 @@ public class TcrSearcher {
     private final Imdg<TradingClearingRegistryList> tcrListImdg;
     private final Imdg<Company> companyImdg;
     private final Imdg<Account> accountImdg;
+    private CashV2ByIdAndString<TradingClearingRegistryList> tcrListCash;
 
+    public void setTcrListCash(CashV2ByIdAndString<TradingClearingRegistryList> tcrListCash) {
+        this.tcrListCash = tcrListCash;
+    }
 
     @Autowired
     public TcrSearcher(ImdgProvider imdgProvider) {
@@ -77,13 +82,10 @@ public class TcrSearcher {
             return acc;
         }
         ImdgPredicateBuilder pb = tcrListImdg.predicateBuilder();
-        TradingClearingRegistryList tcrList = tcrListImdg.getFirstObjectByPredicate(
+        ImdgPredicate tcrListPrdct = TcrListByTcrIdAndCurrencyPredicate
-            pb.and(
+            .getPredicate(tcr.getId(), currency)
-                pb.equals("tradingClearingRegistryId", tcr.getId()),
+            .cashed(pb, tcrListCash);
-                pb.equals("currency", currency),
+        TradingClearingRegistryList tcrList = tcrListImdg.getFirstObjectByPredicate(tcrListPrdct);
-                pb.equals("status", Status.Active.getKey())
-            )
-        );
         if (tcrList == null || tcrList.getAccountId() == null) {
             log.warn("couldn't find account by tcr#id={}; currency {}. tcrList {}.",
                     tcrId, currency, tcrList != null ? (tcrList.getId() + " present though.") : "not found");

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

@@ -22,7 +22,7 @@ import ru.spcex.clearing.session.stage.impl.FinishingSession;
 import ru.spcex.clearing.session.stage.impl.FormingPaymentInstructionAssets;
 import ru.spcex.clearing.session.stage.impl.FormingRegistersOnOS;
 import ru.spcex.clearing.session.stage.impl.InclusionObligations;
-import ru.spcex.clearing.session.stage.impl.InspectionObligations;
+import ru.spcex.clearing.session.stage.impl.InspectionObligationsV2;
 import ru.spcex.clearing.session.stage.impl.ObligationAdmission;
 import ru.spcex.clearing.session.stage.impl.PaymentInfo;
 import ru.spcex.clearing.session.stage.impl.RequirementsAndObligationCreation;
@@ -55,7 +55,7 @@ public class CurrencySession extends AbstractSession implements InitializingBean
     private final ObligationAdmission obligationsAdmission;
 
     private final InclusionObligations inclusionObligations;
-    private final InspectionObligations inspectionObligations;
+    private final InspectionObligationsV2 inspectionObligations;
     private final FormingRegistersOnOS formingRegistersOnOS;
     private final FormingPaymentInstructionAssets formingPaymentInstructionAssets;
     private final UnlockResources unlockResources;
@@ -84,7 +84,7 @@ public class CurrencySession extends AbstractSession implements InitializingBean
             FinishingSession finishingSession,
             EndStageNotification endStageNotification,
             IMessageResolver messageResolver,
-            InspectionObligations inspectionObligations,
+            InspectionObligationsV2 inspectionObligations,
             @Qualifier("marketCodesForCurr") Supplier<List<String>> marketCodes) {
         super(imdgProvider, messageResolver);
         this.balanceRevise = balanceRevise;

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

@@ -9,7 +9,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.classes.statics.data.security.Security;
+import ru.clearing.platform.dictionary.CurrencyPairDictionary;
 import ru.spcex.platform.enumeration.RegistryDesignation;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2;
@@ -30,4 +33,7 @@ public interface IRegistryBuilder {
     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(CashV2<Long, 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

@@ -2,23 +2,21 @@ package ru.spcex.clearing.session.stage.impl;
 
 import java.time.Instant;
 import java.time.LocalDate;
-import java.util.Map;
 import java.util.Optional;
 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.ExecutionCurrency;
 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.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.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;
@@ -37,21 +35,27 @@ 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.specific.SecuritySelector;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.iml.hazelcast.adapter.CashV2;
 
 public class RegistryCurrBuilder implements IRegistryBuilder {
+    private CashV2<Long, Company> cmpCash;
+    private CashV2<Long, Session> ssnCash;
+    private CashV2<Long, TradingClearingRegistry> tcrCash;
+    private CashV2<Long, 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;
     private Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
-    private Imdg<Account> accountImdg;
-    private Imdg<Market> marketImdg;
     private Imdg<Session> sessionImdg;
     private Imdg<ClearingAccount> clearingAccountImdg;
-    private Imdg<InformationAccount> informationAccountImdg;
-    private Imdg<DepoAccount> depoAccountImdg;
     private Imdg<Currency> currencyImdg;
     private Imdg<CurrencyPairSecurity> currPairSecImdg;
     private Imdg<CurrencyPairDictionary> currPairDictImdg;
-    private SecuritySelector<Security> scrSlctr;
     private TcrSearcher tcrSearcher;
     private ExecutionCommon exec;
     private RegistryDesignation regDsgn;
@@ -66,19 +70,18 @@ public class RegistryCurrBuilder implements IRegistryBuilder {
 
     @Override
     public RegistryCurrBuilder imdg(ImdgProvider imdgProvider) {
-        this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        this.companyImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Company, Company.class, cmpCash);
-        this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+        this.tradingClearingRegistryImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class, tcrCash);
-        this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        Imdg<TradingClearingRegistryList> tcrListImdg = imdgProvider.getCashingImdg(
-        this.marketImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Market, Market.class);
+            IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class, tcrListCash
-        this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
+        );
-        this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
+        Imdg<Account> accountImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Account, Account.class, accCash);
-        this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
+        this.sessionImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Session, Session.class, ssnCash);
-        this.informationAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class);
+        this.clearingAccountImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class, null);
-        this.currPairSecImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class);
+        this.currPairSecImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class, currPairCash);
-        this.currPairDictImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class);
+        this.currPairDictImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class, currPairDictCash);
-        this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
+        this.currencyImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Currency, Currency.class, null);
-        this.scrSlctr = new SecuritySelector<>(imdgProvider, Security.class);
+        this.tcrSearcher = new TcrSearcher(tradingClearingRegistryImdg, tcrListImdg, companyImdg, accountImdg);
-        this.tcrSearcher = new TcrSearcher(imdgProvider);
         return this;
     }
 
@@ -126,12 +129,10 @@ public class RegistryCurrBuilder implements IRegistryBuilder {
         //OM_T = CNY  [base_currency_id]  balance=quantity
         //TM_T = RUB [quote_currency_id]  balance=settlement_ammount
         reg.setContract(String.valueOf(exec.getSecurityId()));
-        CurrencyPairSecurity curPairSec = currPairSecImdg.getFirstObjectBySQL(
+        CurrencyPairSecurity curPairSec = currPairSecImdg.getSingleObjectByID(exec.getSecurityId());
-            "id = %d".formatted(exec.getSecurityId())
-        );
         CurrencyPairDictionary curPairDict = null;
         if (curPairSec != null) {
-            curPairDict = currPairDictImdg.getFirstObjectBySQL("id = %d".formatted(curPairSec.getCurrencyPairId()));
+            curPairDict = currPairDictImdg.getSingleObjectByID(curPairSec.getCurrencyPairId());
         }
         assert curPairSec != null && curPairDict != null;
         ExecutionCurrency execCurr = (ExecutionCurrency) this.exec;
@@ -151,9 +152,11 @@ public class RegistryCurrBuilder implements IRegistryBuilder {
             curr = baseCurrency;
             reg.setBalance(execCurr.getQuantity());
         } else curr = CurrencyCode.RUB.getKey();
-        currency = currencyImdg.getFirstObjectByFieldValues(
+        ImdgPredicate currPrdct = CurrencyCodePredicate
-            Map.of("currencyCode", curr)
+            .getPredicate(curr)
-        );
+            .cashed(currencyImdg.predicateBuilder(), currCash);
+
+        currency = currencyImdg.getFirstObjectByPredicate(currPrdct);
         reg.setSecurityId(currency.getId());
         reg.setSecuritySymbol(currency.getCurrencyCode());
         Optional<Account> acc = tcrSearcher.searchByTcr(exec.getTradingClearingRegistryId(), curr);
@@ -212,7 +215,7 @@ public class RegistryCurrBuilder implements IRegistryBuilder {
     }
 
     private Company searchCompany() {
-        return companyImdg.getFirstObjectBySQL("id = " + exec.getCompanyId());
+        return companyImdg.getSingleObjectByID(exec.getCompanyId());
     }
 
     private TradingClearingRegistry searchTradingClearingRegistry() {
@@ -234,7 +237,10 @@ public class RegistryCurrBuilder implements IRegistryBuilder {
     private String defineCapacityByAccountType(String accountType, Long moneyAccountId) {
         String capacityByAccount = null;
         if (AccountType.Clrn.equalsByKey(accountType)) {
-            ClearingAccount clearingAccount = clearingAccountImdg.getFirstObjectByFieldValues(Map.of("accountId", moneyAccountId));
+            ImdgPredicate prdct = AccountIdCashingPredicate
+                .getPredicate(moneyAccountId)
+                .cashed(clearingAccountImdg.predicateBuilder(), clrAccCash);
+            ClearingAccount clearingAccount = clearingAccountImdg.getFirstObjectByPredicate(prdct);
             if (clearingAccount != null) {
                 capacityByAccount = clearingAccount.getClearingAccountType();
             }
@@ -243,4 +249,58 @@ 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;
+        return this;
+    }
+
+    @Override
+    public IRegistryBuilder clrAccCash(CashV2<Long, ClearingAccount> clrAccCash) {
+        this.clrAccCash = clrAccCash;
+        return this;
+    }
+
+    @Override
+    public IRegistryBuilder ssnCash(CashV2<Long, Session> ssnCash) {
+        this.ssnCash = ssnCash;
+        return this;
+    }
+
+    @Override
+    public IRegistryBuilder tcrListCash(CashV2<Long, 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/RequirementsAndObligationCreation.java

@@ -1,6 +1,7 @@
 package ru.spcex.clearing.session.stage.impl;
 
 import java.time.LocalDate;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -24,7 +25,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.classes.statics.data.security.Security;
+import ru.clearing.platform.dictionary.CurrencyPairDictionary;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.session.stage.ISessionStage;
 import ru.spcex.clearing.session.stage.StageResult;
@@ -156,7 +160,8 @@ public class RequirementsAndObligationCreation implements ISessionStage {
                                         .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)
                                         //------
@@ -345,17 +350,23 @@ public class RequirementsAndObligationCreation implements ISessionStage {
         private final CashV2<String, Currency> currCash;
         private final CashV2<Long, ClearingAccount> clrAccCash;
         private final CashV2<Long, Session> ssnCash;
+        private final CashV2<Long, CurrencyPairSecurity> currPairCash;
+        private final CashV2<Long, CurrencyPairDictionary> currPairDictCash;
+        private final CashV2<Long, TradingClearingRegistryList> tcrListCash;
 
         public RequirementsAndObligationCreationCash() {
-            cmpCash = new CashV2ById<>("cmpCash");
+            cashes = new ArrayList<>();
-            tcrCash = new CashV2ById<>("tcrCash");
+            cmpCash = add(new CashV2ById<>("cmpCash"));
-            accCash = new CashV2ById<>("accCash");
+            tcrCash = add(new CashV2ById<>("tcrCash"));
-            dpAccCash = new CashV2ById<>("dpAccCash");
+            accCash = add(new CashV2ById<>("accCash"));
-            scrtCash = new CashV2ById<>("scrtCash");
+            dpAccCash = add(new CashV2ById<>("dpAccCash"));
-            currCash = new CashV2ByString<>("currCash", Currency::getCurrencyCode);
+            scrtCash = add(new CashV2ById<>("scrtCash"));
-            clrAccCash = new CashV2ById<>("clrAccCash");
+            currCash = add(new CashV2ByString<>("currCash", Currency::getCurrencyCode));
-            ssnCash = new CashV2ById<>("ssnCash");
+            clrAccCash = add(new CashV2ById<>("clrAccCash"));
-            cashes = List.of(cmpCash, tcrCash, accCash, dpAccCash, scrtCash, currCash, clrAccCash, ssnCash);
+            ssnCash = add(new CashV2ById<>("ssnCash"));
+            currPairCash = add(new CashV2ById<>("currPairCash"));
+            currPairDictCash = add(new CashV2ById<>("currPairDictCash"));
+            tcrListCash = add(new CashV2ById<>("tcrListCash"));
         }
     }
 }

platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/CashCloser.java

@@ -12,11 +12,16 @@ public class CashCloser implements AutoCloseable {
 
     public CashCloser() {}
 
-    public CashCloser add(CashV2<?, ?> cash) {
+    protected <C extends CashV2<K, T>, K, T> C add(C cash) {
         this.cashes.add(cash);
-        return this;
+        return cash;
     }
 
+//    public CashCloser add(CashV2<?, ?> cash) {
+//        this.cashes.add(cash);
+//        return this;
+//    }
+
     @Override
     public void close() {
         cashes.forEach(CashV2::clear);

platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/CashV2ByIdAndString.java

@@ -0,0 +1,56 @@
+package ru.spcex.platform.imdg.iml.hazelcast.adapter;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class CashV2ByIdAndString<T> extends CashV2<CashV2ByIdAndString.CustomKey, T> {
+
+    private final Function<T, CustomKey> codeExtractor;
+
+    public CashV2ByIdAndString(Function<T, CustomKey> codeExtractor) {
+        this.codeExtractor = codeExtractor;
+    }
+
+    public CashV2ByIdAndString(String name, Function<T, CustomKey> codeExtractor) {
+        super(name);
+        this.codeExtractor = codeExtractor;
+    }
+
+    @Override
+    public Optional<T> getOrFind(CustomKey key, Supplier<T> supplier) {
+        return super.getOrFind(key, supplier);
+    }
+
+    @Override
+    public Optional<T> get(CustomKey key) {
+        return super.get(key);
+    }
+
+    @Override
+    protected CustomKey extractKey(T obj) {
+
+        return codeExtractor.apply(obj);
+    }
+
+    public static record CustomKey(Long id, String code) {
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            CustomKey customKey = (CustomKey) o;
+
+            if (!Objects.equals(id, customKey.id)) return false;
+            return Objects.equals(code, customKey.code);
+        }
+
+        @Override
+        public int hashCode() {
+            int result = id != null ? id.hashCode() : 0;
+            result = 31 * result + (code != null ? code.hashCode() : 0);
+            return result;
+        }
+    }
+}