From dc0a2143066f213c0ad64582a97079f6471c92df Mon Sep 17 00:00:00 2001 From: ialbert Date: Tue, 7 Feb 2023 16:41:55 +0300 Subject: [PATCH] http://jira.mfd.msk:8088/browse/CLS-189 --- .../ru/spcex/clearing/service/Clearing.java | 119 ++++++++++----- .../LiabilitiesClaimsAssetsCreator.java | 135 +++++++++++++++--- 2 files changed, 198 insertions(+), 56 deletions(-) diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/Clearing.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/Clearing.java index d6111abc7..f736737b9 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/Clearing.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/Clearing.java @@ -8,7 +8,6 @@ import ru.clearing.classes.statics.data.execution.ExecutionDeposit; import ru.clearing.classes.statics.data.generated.ClearingMemberCategory; import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets; import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney; -import ru.clearing.classes.statics.data.payment.PaymentInstruction; import ru.spcex.clearing.error.ClearingErrorInternal; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.Consts; @@ -32,6 +31,8 @@ import ru.spcex.platform.utils.validation.IValidator; import java.time.Instant; import java.util.*; import java.util.function.BiFunction; +import java.util.function.Consumer; +import java.util.function.Supplier; @Service public class Clearing { @@ -192,49 +193,73 @@ public class Clearing { continue; } } - LiabilitiesClaimsAssets lca = lbltsClmsAssetsCreator.createLiabilitiesClaimsAssets(category, execDeposit); - liabilitiesClaimsAssetsImdg.insert(lca); - log.trace("LiabilitiesClaimsAssets {} was created", lca.getId()); - Optional lcmFirstLegFound = lbltsClmsMoneyCreator.searchLcmBySettlementDate(lca.getAccountId(), lca.getCompanyId(), lca.getSettlementDate()); - var wrapperFirstLegCreated = new Object() {LiabilitiesClaimsMoney firstLegCreated;}; - lcmFirstLegFound.ifPresentOrElse(lcm -> { + Optional lcaFirstLegFound = lbltsClmsAssetsCreator.searchLCA( + execDeposit.getAccountId(), execDeposit.getCompanyId(), + execDeposit.getSecurityId(), execDeposit.getFirstLegSettlementDate()); + LiabilitiesClaimsAssets lcaFirstLeg = orElse(lcaFirstLegFound).ifPresentOrElse(lca -> { + log.trace("LiabilitiesClaimsAssets first leg {} was found", lca.getId()); + lbltsClmsAssetsCreator.updateFirstLegLca(lca, execDeposit, category); + liabilitiesClaimsAssetsImdg.update(lca); + }, () -> { + log.trace("LiabilitiesClaimsAssets first leg was not found"); + LiabilitiesClaimsAssets lca = lbltsClmsAssetsCreator.createFirstLegLCA(category, execDeposit); + liabilitiesClaimsAssetsImdg.insert(lca); + log.trace("LiabilitiesClaimsAssets {} first leg was created", lca.getId()); + return lca; + }); + Optional lcaSecondLegFound = lbltsClmsAssetsCreator.searchLCA( + execDeposit.getAccountId(), execDeposit.getCompanyId(), + execDeposit.getSecurityId(), execDeposit.getSecondLegSettlementDate()); + LiabilitiesClaimsAssets lcaSecondLeg = orElse(lcaSecondLegFound).ifPresentOrElse(lca -> { + log.trace("LiabilitiesClaimsAssets second leg {} was found", lca.getId()); + lbltsClmsAssetsCreator.updateSecondLegLca(lca, execDeposit, category); + liabilitiesClaimsAssetsImdg.update(lca); + }, () -> { + log.trace("LiabilitiesClaimsAssets second leg was not found"); + LiabilitiesClaimsAssets lca = lbltsClmsAssetsCreator.createSecondLegLCA(category, execDeposit); + liabilitiesClaimsAssetsImdg.insert(lca); + log.trace("LiabilitiesClaimsAssets {} second leg was created", lca.getId()); + return lca; + }); + + Optional lcmFirstLegFound = lbltsClmsMoneyCreator.searchLcmBySettlementDate(lcaFirstLeg.getAccountId(), lcaFirstLeg.getCompanyId(), lcaFirstLeg.getSettlementDate()); + LiabilitiesClaimsMoney lcmFirstLeg = orElse(lcmFirstLegFound).ifPresentOrElse(lcm -> { log.trace("LiabilitiesClaimsMoney first leg {} was found", lcm.getId()); - lbltsClmsMoneyCreator.updateFirstLegLcm(lcm, lca, category); + lbltsClmsMoneyCreator.updateFirstLegLcm(lcm, lcaFirstLeg, category); liabilitiesClaimsMoneyImdg.update(lcm); }, () -> { - LiabilitiesClaimsMoney lcmFirstLeg = lbltsClmsMoneyCreator.createFirstLegLcm(lca, category); - liabilitiesClaimsMoneyImdg.insert(lcmFirstLeg); - log.trace("LiabilitiesClaimsMoney first leg {} was created", lcmFirstLeg.getId()); - wrapperFirstLegCreated.firstLegCreated = lcmFirstLeg; + LiabilitiesClaimsMoney lcm = lbltsClmsMoneyCreator.createFirstLegLcm(lcaFirstLeg, category); + liabilitiesClaimsMoneyImdg.insert(lcm); + log.trace("LiabilitiesClaimsMoney first leg {} was created", lcm.getId()); + return lcm; }); - Optional lcmSecondLegFound = lbltsClmsMoneyCreator.searchLcmByRefundDate(lca.getAccountId(), lca.getCompanyId(), lca.getRefundDate()); - var wrapperSecondLegCreated = new Object() {LiabilitiesClaimsMoney secondLegCreated;}; - lcmSecondLegFound.ifPresentOrElse(lcm -> { + Optional lcmSecondLegFound = lbltsClmsMoneyCreator.searchLcmBySettlementDate(lcaSecondLeg.getAccountId(), lcaSecondLeg.getCompanyId(), lcaSecondLeg.getSettlementDate()); + LiabilitiesClaimsMoney lcmSecondLeg = orElse(lcmSecondLegFound).ifPresentOrElse(lcm -> { log.trace("LiabilitiesClaimsMoney second leg {} was found", lcm.getId()); - lbltsClmsMoneyCreator.updateSecondLegLcm(lcm, lca, category); + lbltsClmsMoneyCreator.updateSecondLegLcm(lcm, lcaSecondLeg, category); liabilitiesClaimsMoneyImdg.update(lcm); }, () -> { - LiabilitiesClaimsMoney lcmSecondLeg = lbltsClmsMoneyCreator.createSecondLegLcm(lca, category); - liabilitiesClaimsMoneyImdg.insert(lcmSecondLeg); - log.trace("LiabilitiesClaimsMoney second leg {} was created", lcmSecondLeg.getId()); - wrapperSecondLegCreated.secondLegCreated = lcmSecondLeg; + LiabilitiesClaimsMoney lcm = lbltsClmsMoneyCreator.createSecondLegLcm(lcaSecondLeg, category); + liabilitiesClaimsMoneyImdg.insert(lcm); + log.trace("LiabilitiesClaimsMoney second leg {} was created", lcm.getId()); + return lcm; }); - lbltsClmsAssetsCreator.updateLca(lca, lcmFirstLegFound.orElse(wrapperFirstLegCreated.firstLegCreated)); - liabilitiesClaimsAssetsImdg.update(lca); + lbltsClmsAssetsCreator.setLcaLcmId(lcaFirstLeg, lcmFirstLeg); + liabilitiesClaimsAssetsImdg.update(lcaFirstLeg); + lbltsClmsAssetsCreator.setLcaLcmId(lcaSecondLeg, lcmSecondLeg); + liabilitiesClaimsAssetsImdg.update(lcaSecondLeg); log.trace("creating paymentInstructions"); - List paymentInstructions = paymentInstructionCreator.createAndSavePaymentInstructions(lca, Collections.singleton(category)); - paymentInstructionCreator.updateFieldLiabilitiesClaimsAssetsByPayment(lca, paymentInstructions, Collections.singleton(category)); - liabilitiesClaimsAssetsImdg.update(lca); - var firstLegLiabilitiesClaimsMoney = lcmFirstLegFound.orElseGet(() -> wrapperFirstLegCreated.firstLegCreated); - var secondLegLiabilitiesClaimsMoney = lcmSecondLegFound.orElseGet(() -> wrapperSecondLegCreated.secondLegCreated); - log.trace("updating LiabilitiesClaimsMoney by payment"); - log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", firstLegLiabilitiesClaimsMoney, secondLegLiabilitiesClaimsMoney); - if (paymentInstructionCreator.updateFieldLiabilitiesClaimsMoneyByPayment(firstLegLiabilitiesClaimsMoney, true, paymentInstructions, Collections.singleton(category)) ) { - liabilitiesClaimsMoneyImdg.update(firstLegLiabilitiesClaimsMoney); - log.trace("LiabilitiesClaimsMoney first leg {} was updated", firstLegLiabilitiesClaimsMoney.getId(), secondLegLiabilitiesClaimsMoney.getId()); - } - log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", firstLegLiabilitiesClaimsMoney, secondLegLiabilitiesClaimsMoney); +// List paymentInstructions = paymentInstructionCreator.createAndSavePaymentInstructions(lca, Collections.singleton(category)); +// paymentInstructionCreator.updateFieldLiabilitiesClaimsAssetsByPayment(lca, paymentInstructions, Collections.singleton(category)); +// liabilitiesClaimsAssetsImdg.update(lca); +// log.trace("updating LiabilitiesClaimsMoney by payment"); +// log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", lcmFirstLeg, lcmSecondLeg); +// if (paymentInstructionCreator.updateFieldLiabilitiesClaimsMoneyByPayment(lcmFirstLeg, true, paymentInstructions, Collections.singleton(category)) ) { +// liabilitiesClaimsMoneyImdg.update(lcmFirstLeg); +// log.trace("LiabilitiesClaimsMoney first leg {} was updated", lcmFirstLeg.getId()); +// } + log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", lcmFirstLeg.getId(), lcmSecondLeg.getId()); execDeposit.setSessionId(clearingSessionId); execDeposit.setUpdated(Instant.now()); executionDepositImdg.update(execDeposit); @@ -244,4 +269,30 @@ public class Clearing { public void setLastAccBalanceResponseId(Long lastAccBalanceResponseId) { this.lastAccBalanceResponseId = lastAccBalanceResponseId; } + + private static OrElse orElse( Optional optional) { + return new OrElse<>(optional); + } + + private static class OrElse implements IOptionalOrElse { + private final Optional optional; + + private OrElse(Optional optional) { + this.optional = optional; + } + + @Override + public T ifPresentOrElse(Consumer consumer, Supplier orElse) { + if (optional.isPresent()) { + consumer.accept(optional.get()); + return optional.get(); + } else { + return orElse.get(); + } + } + } + + private interface IOptionalOrElse { + T ifPresentOrElse(Consumer consumer, Supplier orElse); + } } diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/LiabilitiesClaimsAssetsCreator.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/LiabilitiesClaimsAssetsCreator.java index 85876ea63..68ca536d0 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/LiabilitiesClaimsAssetsCreator.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/LiabilitiesClaimsAssetsCreator.java @@ -13,42 +13,34 @@ import ru.spcex.platform.enumeration.ClearingCategory; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.utils.enumeration.IEnumKey; +import ru.spcex.platform.utils.number.BigDecimalUtil; +import java.math.BigDecimal; import java.time.Instant; import java.time.LocalDate; +import java.util.Map; +import java.util.Optional; @Component public class LiabilitiesClaimsAssetsCreator { private final Imdg accountImdg; private final Imdg companyImdg; + private final Imdg assetsImdg; @Autowired public LiabilitiesClaimsAssetsCreator(ImdgProvider imdgProvider) { this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + this.assetsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_LiabilitiesClaimsAssets, LiabilitiesClaimsAssets.class); } - - public LiabilitiesClaimsAssets createLiabilitiesClaimsAssets(ClearingCategory category, ExecutionDeposit executionDeposit) { + private LiabilitiesClaimsAssets createLCA(ExecutionDeposit executionDeposit, Account account) { LiabilitiesClaimsAssets liabilitiesClaimsAssets = new LiabilitiesClaimsAssets(); liabilitiesClaimsAssets.setCompanyId(executionDeposit.getCompanyId()); liabilitiesClaimsAssets.setAccountId(executionDeposit.getAccountId()); - Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId()); liabilitiesClaimsAssets.setAccountType(account.getAccountType()); liabilitiesClaimsAssets.setAccount(account.getAccount()); - AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()); - boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType); - boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType); - boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType); - - if (iClrn || vInfo) { - liabilitiesClaimsAssets.setLiabilitiesQuantity(executionDeposit.getFirstLegAmount()); - } - if (bClrn) { - liabilitiesClaimsAssets.setClaimsQuantity(executionDeposit.getSecondLegAmount()); - } liabilitiesClaimsAssets.setCurrency(executionDeposit.getSettlementCurrency()); - liabilitiesClaimsAssets.setSettlementDate(executionDeposit.getFirstLegSettlementDate()); liabilitiesClaimsAssets.setTradingDate(executionDeposit.getTradingDate()); liabilitiesClaimsAssets.setRefundDate(executionDeposit.getSecondLegSettlementDate()); liabilitiesClaimsAssets.setPrice(executionDeposit.getPrice()); @@ -59,18 +51,117 @@ public class LiabilitiesClaimsAssetsCreator { liabilitiesClaimsAssets.setShortName(company.getShortName()); liabilitiesClaimsAssets.setContract(executionDeposit.getSecuritySymbol()); liabilitiesClaimsAssets.setFullName(company.getFullName()); - //todo liabilitiesClaimsAssets.setLiabilitiesClaimsMoneyId(company.getFullName()); - //fixme liabilitiesClaimsAssets.setClearingStatus(); - //todo liabilitiesClaimsAssets.setPaymentId(); - //todo liabilitiesClaimsAssets.setRefundPaymentId(); liabilitiesClaimsAssets.setCreated(Instant.now()); liabilitiesClaimsAssets.setClearingDate(LocalDate.now()); return liabilitiesClaimsAssets; } - public void updateLca(LiabilitiesClaimsAssets lca, - LiabilitiesClaimsMoney firstLeg) { - lca.setLiabilitiesClaimsMoneyId(firstLeg.getId()); + + public LiabilitiesClaimsAssets createFirstLegLCA(ClearingCategory category, ExecutionDeposit executionDeposit) { + Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId()); + LiabilitiesClaimsAssets lca = createLCA(executionDeposit, account); + lca.setSettlementDate(executionDeposit.getFirstLegSettlementDate()); + AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()); + boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType); + boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType); + boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType); + + if (iClrn || vInfo) { + lca.setLiabilitiesQuantity(executionDeposit.getFirstLegAmount()); + } + if (bClrn) { + lca.setClaimsQuantity(executionDeposit.getFirstLegAmount()); + } + return lca; + } + + public LiabilitiesClaimsAssets createSecondLegLCA(ClearingCategory category, ExecutionDeposit executionDeposit) { + Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId()); + LiabilitiesClaimsAssets lca = createLCA(executionDeposit, account); + lca.setSettlementDate(executionDeposit.getSecondLegSettlementDate()); + AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()); + boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType); + boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType); + boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType); + if (iClrn || vInfo) { + lca.setClaimsQuantity(executionDeposit.getSecondLegAmount()); + } + if (bClrn) { + lca.setLiabilitiesQuantity(executionDeposit.getSecondLegAmount()); + } + return null; + } + + public void setLcaLcmId(LiabilitiesClaimsAssets lca, + LiabilitiesClaimsMoney lcm) { + lca.setLiabilitiesClaimsMoneyId(lcm.getId()); lca.setUpdated(Instant.now()); } + + public Optional searchLCA(Long accountId, + Long companyId, + Long securityId, + LocalDate dt) { + LiabilitiesClaimsAssets asset = assetsImdg.getSingleObjectByFieldValues( + Map.of("accountId", accountId, + "companyId", companyId, + "securityId", securityId, + "settlementDate", dt)); + return Optional.ofNullable(asset); + } + + + public void updateSecondLegLca(LiabilitiesClaimsAssets lca, ExecutionDeposit executionDeposit, ClearingCategory category) { + Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId()); + AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()); + boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType); + boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType); + boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType); + if (iClrn || vInfo) { + BigDecimal prevCQuantity = BigDecimalUtil.safeBD(lca.getClaimsQuantity()); + BigDecimal secondLegAmount = BigDecimalUtil.safeBD(executionDeposit.getSecondLegAmount()); + lca.setClaimsQuantity(prevCQuantity.add(secondLegAmount)); + } + if (bClrn) { + BigDecimal prevLQuantity = BigDecimalUtil.safeBD(lca.getLiabilitiesQuantity()); + BigDecimal secondLegAmount = BigDecimalUtil.safeBD(executionDeposit.getSecondLegAmount()); + lca.setLiabilitiesQuantity(prevLQuantity.add(secondLegAmount)); + } + } + + public void updateFirstLegLca(LiabilitiesClaimsAssets lca, ExecutionDeposit executionDeposit, ClearingCategory category) { + Account account = accountImdg.getSingleObjectByID(executionDeposit.getAccountId()); + AccountType accType = IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()); + boolean iClrn = ClearingCategory.I.equals(category) && AccountType.Clrn.equals(accType); + boolean vInfo = ClearingCategory.V.equals(category) && AccountType.Info.equals(accType); + boolean bClrn = ClearingCategory.B.equals(category) && AccountType.Clrn.equals(accType); + //liabilitiesQuantity + //Клиринг (по первой ноге и категория I и счет CLRN): + //текущее значение liabilitiesClaimsAssets.liabilitiesQuantity + executionDeposit.firstLegAmount + if (iClrn || vInfo) { + BigDecimal prevLQuantity = BigDecimalUtil.safeBD(lca.getLiabilitiesQuantity()); + BigDecimal firstLegAmount = BigDecimalUtil.safeBD(executionDeposit.getFirstLegAmount()); + lca.setLiabilitiesQuantity(prevLQuantity.add(firstLegAmount)); + } + if (bClrn) { + BigDecimal prevCQuantity = BigDecimalUtil.safeBD(lca.getClaimsQuantity()); + BigDecimal firstLegAmount = BigDecimalUtil.safeBD(executionDeposit.getFirstLegAmount()); + lca.setClaimsQuantity(prevCQuantity.add(firstLegAmount)); + } + // + //Клиринг (по второй ноге и категория I и счет CLRN): + //не меняется. + // + // Клиринг (по первой ноге и категория V и счет INFO): + //текущее значение liabilitiesClaimsAssets.liabilitiesQuantity + executionDeposit.firstLegAmount + // + //Клиринг (по второй ноге и категория V и счет INFO): + //не меняется. + // + //Клиринг (по первой ноге и категория B и счет CLRN): + //не меняется. + // + //Клиринг (по второй ноге и категория B и счет CLRN): + //= текущее значение liabilitiesClaimsAssets.liabilitiesQuantity + executionDeposit.secondLegAmount + } }