http://jira.mfd.msk:8088/browse/CLS-189

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);
+            Optional<LiabilitiesClaimsAssets> lcaFirstLegFound = lbltsClmsAssetsCreator.searchLCA(
-            liabilitiesClaimsAssetsImdg.insert(lca);
+                    execDeposit.getAccountId(), execDeposit.getCompanyId(),
-            log.trace("LiabilitiesClaimsAssets {} was created", lca.getId());
+                    execDeposit.getSecurityId(), execDeposit.getFirstLegSettlementDate());
-            Optional<LiabilitiesClaimsMoney> lcmFirstLegFound = lbltsClmsMoneyCreator.searchLcmBySettlementDate(lca.getAccountId(), lca.getCompanyId(), lca.getSettlementDate());
+            LiabilitiesClaimsAssets lcaFirstLeg = orElse(lcaFirstLegFound).ifPresentOrElse(lca -> {
-            var wrapperFirstLegCreated = new Object() {LiabilitiesClaimsMoney firstLegCreated;};
+                log.trace("LiabilitiesClaimsAssets first leg {} was found", lca.getId());
-            lcmFirstLegFound.ifPresentOrElse(lcm -> {
+                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<LiabilitiesClaimsAssets> 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<LiabilitiesClaimsMoney> 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);
+                LiabilitiesClaimsMoney lcm = lbltsClmsMoneyCreator.createFirstLegLcm(lcaFirstLeg, category);
-                liabilitiesClaimsMoneyImdg.insert(lcmFirstLeg);
+                liabilitiesClaimsMoneyImdg.insert(lcm);
-                log.trace("LiabilitiesClaimsMoney first leg {} was created", lcmFirstLeg.getId());
+                log.trace("LiabilitiesClaimsMoney first leg {} was created", lcm.getId());
-                wrapperFirstLegCreated.firstLegCreated = lcmFirstLeg;
+                return lcm;
             });
-            Optional<LiabilitiesClaimsMoney> lcmSecondLegFound = lbltsClmsMoneyCreator.searchLcmByRefundDate(lca.getAccountId(), lca.getCompanyId(), lca.getRefundDate());
+            Optional<LiabilitiesClaimsMoney> lcmSecondLegFound = lbltsClmsMoneyCreator.searchLcmBySettlementDate(lcaSecondLeg.getAccountId(), lcaSecondLeg.getCompanyId(), lcaSecondLeg.getSettlementDate());
-            var wrapperSecondLegCreated = new Object() {LiabilitiesClaimsMoney secondLegCreated;};
+            LiabilitiesClaimsMoney lcmSecondLeg = orElse(lcmSecondLegFound).ifPresentOrElse(lcm -> {
-            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);
+                LiabilitiesClaimsMoney lcm = lbltsClmsMoneyCreator.createSecondLegLcm(lcaSecondLeg, category);
-                liabilitiesClaimsMoneyImdg.insert(lcmSecondLeg);
+                liabilitiesClaimsMoneyImdg.insert(lcm);
-                log.trace("LiabilitiesClaimsMoney second leg {} was created", lcmSecondLeg.getId());
+                log.trace("LiabilitiesClaimsMoney second leg {} was created", lcm.getId());
-                wrapperSecondLegCreated.secondLegCreated = lcmSecondLeg;
+                return lcm;
             });
-            lbltsClmsAssetsCreator.updateLca(lca, lcmFirstLegFound.orElse(wrapperFirstLegCreated.firstLegCreated));
+            lbltsClmsAssetsCreator.setLcaLcmId(lcaFirstLeg, lcmFirstLeg);
-            liabilitiesClaimsAssetsImdg.update(lca);
+            liabilitiesClaimsAssetsImdg.update(lcaFirstLeg);
+            lbltsClmsAssetsCreator.setLcaLcmId(lcaSecondLeg, lcmSecondLeg);
+            liabilitiesClaimsAssetsImdg.update(lcaSecondLeg);
             log.trace("creating paymentInstructions");
 
-            List<PaymentInstruction> paymentInstructions = paymentInstructionCreator.createAndSavePaymentInstructions(lca, Collections.singleton(category));
+//            List<PaymentInstruction> paymentInstructions = paymentInstructionCreator.createAndSavePaymentInstructions(lca, Collections.singleton(category));
-            paymentInstructionCreator.updateFieldLiabilitiesClaimsAssetsByPayment(lca, paymentInstructions, Collections.singleton(category));
+//            paymentInstructionCreator.updateFieldLiabilitiesClaimsAssetsByPayment(lca, paymentInstructions, Collections.singleton(category));
-            liabilitiesClaimsAssetsImdg.update(lca);
+//            liabilitiesClaimsAssetsImdg.update(lca);
-            var firstLegLiabilitiesClaimsMoney = lcmFirstLegFound.orElseGet(() -> wrapperFirstLegCreated.firstLegCreated);
+//            log.trace("updating  LiabilitiesClaimsMoney by payment");
-            var secondLegLiabilitiesClaimsMoney = lcmSecondLegFound.orElseGet(() -> wrapperSecondLegCreated.secondLegCreated);
+//            log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", lcmFirstLeg, lcmSecondLeg);
-            log.trace("updating  LiabilitiesClaimsMoney by payment");
+//            if (paymentInstructionCreator.updateFieldLiabilitiesClaimsMoneyByPayment(lcmFirstLeg, true, paymentInstructions, Collections.singleton(category)) ) {
-            log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", firstLegLiabilitiesClaimsMoney, secondLegLiabilitiesClaimsMoney);
+//                liabilitiesClaimsMoneyImdg.update(lcmFirstLeg);
-            if (paymentInstructionCreator.updateFieldLiabilitiesClaimsMoneyByPayment(firstLegLiabilitiesClaimsMoney, true, paymentInstructions, Collections.singleton(category)) ) {
+//                log.trace("LiabilitiesClaimsMoney first leg {} was updated", lcmFirstLeg.getId());
-                liabilitiesClaimsMoneyImdg.update(firstLegLiabilitiesClaimsMoney);
+//            }
-                log.trace("LiabilitiesClaimsMoney first leg {} was updated", firstLegLiabilitiesClaimsMoney.getId(), secondLegLiabilitiesClaimsMoney.getId());
+            log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", lcmFirstLeg.getId(), lcmSecondLeg.getId());
-            }
-            log.trace("firstLegLiabilitiesClaimsMoney: {}; secondLegLiabilitiesClaimsMoney: {}", firstLegLiabilitiesClaimsMoney, secondLegLiabilitiesClaimsMoney);
             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 <T> OrElse<T> orElse( Optional<T> optional) {
+        return new OrElse<>(optional);
+    }
+
+    private static class OrElse<T> implements IOptionalOrElse<T> {
+        private final Optional<T> optional;
+
+        private OrElse(Optional<T> optional) {
+            this.optional = optional;
+        }
+
+        @Override
+        public T ifPresentOrElse(Consumer<T> consumer, Supplier<T> orElse) {
+            if (optional.isPresent()) {
+                consumer.accept(optional.get());
+                return optional.get();
+            } else {
+                return orElse.get();
+            }
+        }
+    }
+
+    private interface IOptionalOrElse<T> {
+        T ifPresentOrElse(Consumer<T> consumer, Supplier<T> orElse);
+    }
 }

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<Account> accountImdg;
     private final Imdg<Company> companyImdg;
+    private final Imdg<LiabilitiesClaimsAssets> 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);
     }
 
-
+    private LiabilitiesClaimsAssets createLCA(ExecutionDeposit executionDeposit, Account account) {
-    public LiabilitiesClaimsAssets createLiabilitiesClaimsAssets(ClearingCategory category, ExecutionDeposit executionDeposit) {
         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) {
+    public LiabilitiesClaimsAssets createFirstLegLCA(ClearingCategory category, ExecutionDeposit executionDeposit) {
-        lca.setLiabilitiesClaimsMoneyId(firstLeg.getId());
+        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<LiabilitiesClaimsAssets> 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
+    }
 }