diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/component/predicate/cash/tcr/TcrListByTcrIdAndCurrencyPredicate.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/component/predicate/cash/tcr/TcrListByTcrIdAndCurrencyPredicate.java new file mode 100644 index 000000000..498d8a4a1 --- /dev/null +++ b/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 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; + } +} diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/TcrSearcher.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/TcrSearcher.java index 6929e8e44..c47de9ec9 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/TcrSearcher.java +++ b/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 tcrListImdg; private final Imdg companyImdg; private final Imdg accountImdg; + private CashV2ByIdAndString tcrListCash; + public void setTcrListCash(CashV2ByIdAndString 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( - pb.and( - pb.equals("tradingClearingRegistryId", tcr.getId()), - pb.equals("currency", currency), - pb.equals("status", Status.Active.getKey()) - ) - ); + ImdgPredicate tcrListPrdct = TcrListByTcrIdAndCurrencyPredicate + .getPredicate(tcr.getId(), currency) + .cashed(pb, tcrListCash); + TradingClearingRegistryList tcrList = tcrListImdg.getFirstObjectByPredicate(tcrListPrdct); 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"); diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/CurrencySession.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/CurrencySession.java index 430c63290..fd0cfd7da 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/CurrencySession.java +++ b/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> marketCodes) { super(imdgProvider, messageResolver); this.balanceRevise = balanceRevise; diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/IRegistryBuilder.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/IRegistryBuilder.java index ae53d98e6..ce13fed8f 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/IRegistryBuilder.java +++ b/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 currCash) {return this;}//CashV2 currCash; default IRegistryBuilder clrAccCash(CashV2 clrAccCash) {return this;}//CashV2 clrAccCash; default IRegistryBuilder ssnCash(CashV2 ssnCash) {return this;}//CashV2 clrAccCash; + default IRegistryBuilder tcrListCash(CashV2 tcrListCash) {return this;} + default IRegistryBuilder currPairCash(CashV2 currPairCash) {return this;} + default IRegistryBuilder currPairDictCash(CashV2 currPairDictCash) {return this;} } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RegistryCurrBuilder.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RegistryCurrBuilder.java index 0707a10ff..c43ab9673 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RegistryCurrBuilder.java +++ b/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 cmpCash; + private CashV2 ssnCash; + private CashV2 tcrCash; + private CashV2 tcrListCash; + private CashV2 accCash; + private CashV2 currCash; + private CashV2 currPairCash; + private CashV2 currPairDictCash; + private CashV2 clrAccCash; + private Imdg companyImdg; private Imdg tradingClearingRegistryImdg; - private Imdg accountImdg; - private Imdg marketImdg; private Imdg sessionImdg; private Imdg clearingAccountImdg; - private Imdg informationAccountImdg; - private Imdg depoAccountImdg; private Imdg currencyImdg; private Imdg currPairSecImdg; private Imdg currPairDictImdg; - private SecuritySelector 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.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class); - this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); - this.marketImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Market, Market.class); - this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); - this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class); - this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class); - this.informationAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class); - this.currPairSecImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class); - this.currPairDictImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class); - this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class); - this.scrSlctr = new SecuritySelector<>(imdgProvider, Security.class); - this.tcrSearcher = new TcrSearcher(imdgProvider); + this.companyImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Company, Company.class, cmpCash); + this.tradingClearingRegistryImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class, tcrCash); + Imdg tcrListImdg = imdgProvider.getCashingImdg( + IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class, tcrListCash + ); + Imdg 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.currPairSecImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class, currPairCash); + this.currPairDictImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class, currPairDictCash); + this.currencyImdg = imdgProvider.getCashingImdg(IMDGDistributedNames.Map_Currency, Currency.class, null); + this.tcrSearcher = new TcrSearcher(tradingClearingRegistryImdg, tcrListImdg, companyImdg, accountImdg); 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( - "id = %d".formatted(exec.getSecurityId()) - ); + CurrencyPairSecurity curPairSec = currPairSecImdg.getSingleObjectByID(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( - Map.of("currencyCode", curr) - ); + ImdgPredicate currPrdct = CurrencyCodePredicate + .getPredicate(curr) + .cashed(currencyImdg.predicateBuilder(), currCash); + + currency = currencyImdg.getFirstObjectByPredicate(currPrdct); reg.setSecurityId(currency.getId()); reg.setSecuritySymbol(currency.getCurrencyCode()); Optional 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 cmpCash) { + this.cmpCash = cmpCash; + return this; + } + + @Override + public IRegistryBuilder tcrCash(CashV2 tcrCash) { + this.tcrCash = tcrCash; + return this; + } + + @Override + public IRegistryBuilder accCash(CashV2 accCash) { + this.accCash = accCash; + return this; + } + + @Override + public IRegistryBuilder currCash(CashV2 currCash) { + this.currCash = currCash; + return this; + } + + @Override + public IRegistryBuilder clrAccCash(CashV2 clrAccCash) { + this.clrAccCash = clrAccCash; + return this; + } + + @Override + public IRegistryBuilder ssnCash(CashV2 ssnCash) { + this.ssnCash = ssnCash; + return this; + } + + @Override + public IRegistryBuilder tcrListCash(CashV2 tcrListCash) { + this.tcrListCash = tcrListCash; + return this; + } + + @Override + public IRegistryBuilder currPairCash(CashV2 currPairCash) { + this.currPairCash = currPairCash; + return this; + } + + @Override + public IRegistryBuilder currPairDictCash(CashV2 currPairDictCash) { + this.currPairDictCash = currPairDictCash; + return this; + } } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RequirementsAndObligationCreation.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RequirementsAndObligationCreation.java index b6f847050..55d8e2e32 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/RequirementsAndObligationCreation.java +++ b/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 currCash; private final CashV2 clrAccCash; private final CashV2 ssnCash; + private final CashV2 currPairCash; + private final CashV2 currPairDictCash; + private final CashV2 tcrListCash; public RequirementsAndObligationCreationCash() { - cmpCash = new CashV2ById<>("cmpCash"); - tcrCash = new CashV2ById<>("tcrCash"); - accCash = new CashV2ById<>("accCash"); - dpAccCash = new CashV2ById<>("dpAccCash"); - scrtCash = new CashV2ById<>("scrtCash"); - currCash = new CashV2ByString<>("currCash", Currency::getCurrencyCode); - clrAccCash = new CashV2ById<>("clrAccCash"); - ssnCash = new CashV2ById<>("ssnCash"); - cashes = List.of(cmpCash, tcrCash, accCash, dpAccCash, scrtCash, currCash, clrAccCash, ssnCash); + cashes = new ArrayList<>(); + cmpCash = add(new CashV2ById<>("cmpCash")); + 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")); + currPairDictCash = add(new CashV2ById<>("currPairDictCash")); + tcrListCash = add(new CashV2ById<>("tcrListCash")); } } } diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/CashCloser.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/CashCloser.java index 0be1485c7..4c95301c7 100644 --- a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/CashCloser.java +++ b/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 , 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); diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/CashV2ByIdAndString.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/CashV2ByIdAndString.java new file mode 100644 index 000000000..9d4b4feaa --- /dev/null +++ b/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 extends CashV2 { + + private final Function codeExtractor; + + public CashV2ByIdAndString(Function codeExtractor) { + this.codeExtractor = codeExtractor; + } + + public CashV2ByIdAndString(String name, Function codeExtractor) { + super(name); + this.codeExtractor = codeExtractor; + } + + @Override + public Optional getOrFind(CustomKey key, Supplier supplier) { + return super.getOrFind(key, supplier); + } + + @Override + public Optional 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; + } + } +}