В финальной МКР часть про возврат депозитов скопированна из сесси по возвратам депозитов

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

@@ -33,6 +33,7 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryAssetPredicate;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
+import ru.spcex.platform.imdg.api.predicate.specific.RegistryDm_tClrnPredicate;
 import ru.spcex.platform.utils.collection.Pair;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
@@ -300,12 +301,10 @@ public class FormingPaymentInstructionDepositReturn implements ISessionStage {
      * Если УК зачисляет средства на свой ТБС
      */
     private Optional<Registry> searchDmtClrn(Registry rgs) {
-        String sqlCondition = String.format("(%s) and accountType='%s' and companyId = %d and counterPartyId = %d",
+        ImdgPredicate dmtClrnPrdct = RegistryDm_tClrnPredicate
-                RegistryCodeSqlBuilder.getInstance(DM_T).build(),
+                .instance(rgs.getCompanyId(), rgs.getCounterPartyId())
-                AccountType.Clrn.getKey(),
+                .apply(registryImdg);
-                rgs.getCompanyId(),
+        Registry dmt = registryImdg.getSingleObjectByPredicate(dmtClrnPrdct);
-                rgs.getCounterPartyId());
-        Registry dmt = registryImdg.getSingleObjectBySQL(sqlCondition);
         return Optional.ofNullable(dmt);
     }
 

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

@@ -13,6 +13,7 @@ import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.sdf.SDf03;
 import ru.clearing.classes.statics.data.sdf.SDf12;
 import ru.clearing.classes.statics.data.security.Security;
+import ru.spcex.clearing.error.ClearingError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.ExportToFileRequest;
@@ -20,6 +21,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.importexport.SwtExporterR
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.clearing.service.SpecifUtil;
 import ru.spcex.clearing.service.builder.PaymentInstructionBuilder;
+import ru.spcex.clearing.service.builder.PaymentInstructionBuilderFinalMkrDeals;
 import ru.spcex.clearing.session.stage.ISessionStage;
 import ru.spcex.clearing.session.stage.StageResult;
 import ru.spcex.clearing.session.stage.Task;
@@ -30,7 +32,11 @@ import ru.spcex.platform.imdg.api.ImdgId;
 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.RegistryAssetPredicate;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
+import ru.spcex.platform.imdg.api.predicate.specific.RegistryDm_tClrnPredicate;
+import ru.spcex.platform.utils.collection.Pair;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.number.BigDecimalUtil;
 import ru.spcex.platform.utils.time.TimeUtil;
@@ -39,6 +45,7 @@ import java.math.BigDecimal;
 import java.time.Instant;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import static ru.spcex.platform.enumeration.RegistryTradingParams.*;
 
@@ -99,35 +106,9 @@ public class FormingPaymentInstructionReturnMkr implements ISessionStage {
                 .toList();
         log.debug("LM*T and CM*T size = {}", rgsAll.size());
 
-//        List<Registry> obligationsByMoney = rgsAll.stream()
-//                .filter(registry -> equalsByRegistry(LM_T, registry))
-//                .toList();
-//
-//        log.debug("changing assets by LM*T");
-        //изменяем активы по обязательствам по деньгам (LM_T)
-//        for (Registry obligationByMoney : obligationsByMoney) {
-//            String sql = String.format("tradingClearingRegistryId = %s and companyId = %s",
-//                    obligationByMoney.getTradingClearingRegistryId(), obligationByMoney.getCompanyId());
-//            Collection<Registry> relatedRegistries = registryImdg.getCollectionObjectsBySQL(sql);
-//            log.trace("found {} related registries (by tcrId&companyId) for LM*T.id={}",
-//                    relatedRegistries.size(),
-//                    obligationByMoney.getId());
-//
-//            for (Registry relatedRegistry : relatedRegistries) {
-//                if (equalsByRegistry(AM_F, relatedRegistry)) {
-//                    relatedRegistry.setBalance(safeBD(relatedRegistry.getBalance()).subtract(safeBD(obligationByMoney.getBalance())));
-//                } else if (equalsByRegistry(AM_T, relatedRegistry)) {
-//                    relatedRegistry.setSettledDebit(safeBD(relatedRegistry.getSettledDebit()).add(safeBD(obligationByMoney.getBalance())));
-//                } else if (equalsByRegistry(AM_B, relatedRegistry)) {
-//                    relatedRegistry.setBalance(safeBD(relatedRegistry.getBalance()).add(safeBD(obligationByMoney.getBalance())));
-//                }
-//                log.trace("updated related registry.id={} for LM*T.id={}", relatedRegistry.getId(), obligationByMoney.getId());
-//                registryImdg.update(relatedRegistry);
-//            }
-//        }
         log.debug("changing assets by CM*T");
         List<Registry> requirementsByMoney = rgsAll.stream()
-                .filter(registry -> equalsByRegistry(CM_T, registry))
+                .filter(registry -> equalByRgs(CM_T, registry))
                 .toList();
         //изменяем активы по требованиям по деньгам CM_T
         for (Registry requirementByMoney : requirementsByMoney) {
@@ -136,7 +117,7 @@ public class FormingPaymentInstructionReturnMkr implements ISessionStage {
             Collection<Registry> relatedRegistries = registryImdg.getCollectionObjectsBySQL(sql);
             log.trace("found {} related registries (by tcrId&companyId) for CM*T.id={}", relatedRegistries.size(), requirementByMoney.getId());
             for (Registry relatedRegistry : relatedRegistries) {
-                if (equalsByRegistry(AM_T, relatedRegistry)) {
+                if (equalByRgs(AM_T, relatedRegistry)) {
                     relatedRegistry.setSettledDebit(safeBD(relatedRegistry.getSettledDebit()).add(safeBD(requirementByMoney.getBalance())));
                     log.trace("updated related registry.id={} for CM*T.id={}", relatedRegistry.getId(), requirementByMoney.getId());
                     registryImdg.update(relatedRegistry);
@@ -144,69 +125,87 @@ public class FormingPaymentInstructionReturnMkr implements ISessionStage {
             }
         }
 
-        List<PaymentInstruction> formedPaymentInstructions = new ArrayList<>();
+        List<PaymentInstruction> pmtCreated = new ArrayList<>();
 
-        List<Registry> allLiabilities = rgsAll
+        Map<Long, List<Registry>> registriesByGroup  = rgsAll
-                .stream()
+                .stream().
-                .filter(registry -> RegistryDesignation.L.equalsByKey(registry.getRegistryDesignation()))
+                collect(Collectors.groupingBy(Registry::getGroupId));
-                .filter(obligation -> {
+        log.info("registry groups found {}", registriesByGroup.size());
-                    //если valueDate < settlement date
+        for (Map.Entry<Long, List<Registry>> entry : registriesByGroup.entrySet()) {
-                    if (!(obligation.getValueDate() != null
+            List<Registry> groupRgs = entry.getValue();
-                            && obligation.getSettlementDate() != null
+            Optional<Registry> lmtO = groupRgs.stream().filter(rgs -> equalByRgs(LM_T, rgs)).findFirst();
-                            && obligation.getValueDate().isBefore(obligation.getSettlementDate()))) {
+            Optional<Registry> cmtO = groupRgs.stream().filter(rgs -> equalByRgs(CM_T, rgs)).findFirst();
-                        return false;
+            if (lmtO.isEmpty() || cmtO.isEmpty()) {
-                    }
+                log.error("LM*T or CM*T not found for group {}", entry.getKey());
-                    Optional<Registry> dmx = searchDmx(obligation);
+                continue;
-                    if (dmx.isPresent()) {
+            }
-                        log.debug("LM*T#id={}, DM*X#id={} found, no action needed for group {}, skipping liability",
+            Registry lm_t = lmtO.get(); //obligation by money
-                                obligation.getId(),
+            Registry cm_t = cmtO.get();
-                                obligation.getId(),
+            Optional<Registry> dmx = searchDmx(lm_t);
-                                obligation.getGroupId());
+            if (dmx.isPresent()) {
-                    }
+                log.debug("LM*T#id={}, DM*X#id={} found, no action needed for group {}, skipping liability",
-                    return dmx.isEmpty();
+                        lm_t.getId(), dmx.get().getId(), lm_t.getGroupId());
-                })
+                continue;
-                .toList();
+            }
-        for (int i = 0; i < allLiabilities.size(); i++) {
+            Optional<Registry> dmtClnr = searchDmtClrn(lm_t);
-            //сортировка чтобы найти сделки с одинаковыми направлениями и адресатами и схлопнуть в одну
+            if (dmtClnr.isPresent()) {
-            Registry lm_t = allLiabilities.get(i);
+                Account tranAcc = accountImdg.getSingleObjectBySQL("accountType = '%s' and status = '%s' and processingSign = '%s'"
-            if (lm_t == null) continue;
+                        .formatted(AccountType.Tran.getKey(), AccountStatus.ACTIVE.getKey(), Allowed.ALLOWED.getKey()));
-            LinkedList<Registry> relatedRegistries = new LinkedList<>();
+                if (tranAcc == null) {
-            relatedRegistries.add(lm_t);
+                    return new StageResult<>(
-            for (int j = i + 1; j < allLiabilities.size(); j++) {
+                            new EnumMessage(ClearingError.AccountNotPresent, "accountType = " + AccountType.Tran.getKey()),
-                Registry related = allLiabilities.get(j);
+                            false);
-                if (related == null) continue;
+                }
-                if (registriesOfTheSameAgents(lm_t, related)) {
+                {
-                    relatedRegistries.add(related);
+                    //изменение активов - блокируем средства беред отправкой sdf'ов
-                    allLiabilities.set(j, null);
+                    Optional<Registry> amfO = findRelatedAsset(lm_t.getTradingClearingRegistryId(), lm_t.getCompanyId(), AM_F);
-                }
+                    Optional<Registry> payerAmtO = findRelatedAsset(lm_t.getTradingClearingRegistryId(), lm_t.getCompanyId(), AM_T);
+                    Optional<Registry> ambO = findRelatedAsset(lm_t.getTradingClearingRegistryId(), lm_t.getCompanyId(), AM_B);
+                    Optional<Registry> receiverAmtO = findRelatedAsset(cm_t.getTradingClearingRegistryId(), cm_t.getCompanyId(), AM_B);
+                    log.debug("changing A* registers based on LM_T.id={} and CM_T.id={} found AM*F.id={}, AM*T.id={}, AM*B.id={}, AM*B.id={}",
+                            lm_t.getId(),
+                            cm_t.getId(),
+                            amfO.map(Registry::getId).orElse(null),
+                            payerAmtO.map(Registry::getId).orElse(null),
+                            ambO.map(Registry::getId).orElse(null),
+                            receiverAmtO.map(Registry::getId).orElse(null)
+                    );
+                    Instant now = Instant.now();
+                    amfO.ifPresent(amf -> {
+                        amf.setBalance(safeBD(amf.getBalance()).subtract(safeBD(lm_t.getBalance())));
+                        setUpdatedStoreInImdg(amf, now);
+                    });
+                    payerAmtO.ifPresent(amt -> {
+                        amt.setSettledDebit(safeBD(amt.getSettledDebit()).add(safeBD(lm_t.getBalance())));
+                        setUpdatedStoreInImdg(amt, now);
+                    });
+                    ambO.ifPresent(amb -> {
+                        amb.setBalance(safeBD(amb.getBalance()).add(safeBD(lm_t.getBalance())));
+                        setUpdatedStoreInImdg(amb, now);
+                    });
+                    receiverAmtO.ifPresent(amt -> {
+                        // у отправителя и получателя одинаково, см. в FormingPaymentInstruction
+                        amt.setSettledDebit(safeBD(amt.getSettledDebit()).add(safeBD(lm_t.getBalance())));
+                        setUpdatedStoreInImdg(amt, now);
+                    });
+                }
+                Pair<PaymentInstruction, PaymentInstruction> pmts = PaymentInstructionBuilderFinalMkrDeals.builder(imdgProvider)
+                        .lm_t(lm_t)
+                        .cm_t(cm_t)
+                        .tranAcc(tranAcc)
+                        .sessionId(sessionId)
+                        .paymentPurpose("Возврат депозита " + cm_t.getContract() + " по ТКР " + cm_t.getTradingClearingRegistry())
+                        .build();
+                paymentInstructionImdg.insert(pmts.getFirst());
+                paymentInstructionImdg.insert(pmts.getSecond());
+                log.debug("LM*T#id={}, CM*T#id={} found, PaymentInstruction id={} and id={} created",
+                        lm_t.getId(), cm_t.getId(), pmts.getFirst().getId(), pmts.getSecond().getId());
+                pmtCreated.add(pmts.getFirst());
+                pmtCreated.add(pmts.getSecond());
             }
-            log.trace("LM*T.id={} return group size {}", lm_t.getId(), relatedRegistries.size());
-            BigDecimal sumBalance = relatedRegistries.stream().map(Registry::getBalance).reduce(BigDecimal.ZERO, BigDecimal::add);
-            log.trace("LM*T.id={} sumBalance={}", lm_t.getId(), sumBalance);
-            List<Registry> builderList = new ArrayList<>();
-            builderList.add(lm_t);
-            rgsAll.stream()
-                    .filter(rgs -> rgs.getGroupId().equals(lm_t.getGroupId()))
-                    .filter(rgs -> RegistryDesignation.C.equalsByKey(rgs.getRegistryDesignation()))
-                    .findFirst()
-                    .ifPresent(builderList::add);
-
-            PaymentInstruction paymentInstruction = createPaymentInstruction(builderList, sumBalance, sessionId);
-            formedPaymentInstructions.add(paymentInstruction);
-            paymentInstructionImdg.insert(paymentInstruction);
-            log.trace("LM*T.id={} created paymentInstruction.id={}", lm_t.getId(), paymentInstruction.getId());
-            builderList.forEach(registry -> {
-                registry.setPaymentId(paymentInstruction.getId());
-                registry.setUpdated(Instant.now());
-                registryImdg.update(registry);
-            });
         }
-
-        //sdf отправляют
-        //sendSdfs(formedPaymentInstructions);
-
         StageResult<Collection<PaymentInstruction>> stageResult = new StageResult(null, true);
-        stageResult.setStageResult(formedPaymentInstructions);
+        stageResult.setStageResult(pmtCreated);
         return stageResult;
     }
 
@@ -221,6 +220,26 @@ public class FormingPaymentInstructionReturnMkr implements ISessionStage {
         return Optional.ofNullable(dmx);
     }
 
+    private Optional<Registry> searchDmtClrn(Registry rgs) {
+        ImdgPredicate dmtClrnPrdct = RegistryDm_tClrnPredicate
+                .instance(rgs.getCompanyId(), rgs.getCounterPartyId())
+                .apply(registryImdg);
+        Registry dmt = registryImdg.getSingleObjectByPredicate(dmtClrnPrdct);
+        return Optional.ofNullable(dmt);
+    }
+
+    private Optional<Registry> findRelatedAsset(Long tradingClearingRegistryId, Long companyId, RegistryTradingParams rgsCode) {
+        ImdgPredicate prdct = RegistryAssetPredicate
+                .instance(tradingClearingRegistryId, companyId, rgsCode)
+                .apply(registryImdg);
+        return Optional.ofNullable(registryImdg.getSingleObjectByPredicate(prdct));
+    }
+
+    private void setUpdatedStoreInImdg(Registry rgs, Instant now) {
+        rgs.setUpdated(now);
+        registryImdg.update(rgs);
+    }
+
     private void sendSdfs(List<PaymentInstruction> formedPaymentInstructions) {
         List<SDf03> sDf03Created = new ArrayList<>();
         List<SDf12> sDf12Created = new ArrayList<>();
@@ -370,7 +389,7 @@ public class FormingPaymentInstructionReturnMkr implements ISessionStage {
                 && Objects.equals(rgs1.getCounterPartyId(), rgs2.getCounterPartyId());
     }
 
-    private static boolean equalsByRegistry(RegistryTradingParams code, Registry rgs) {
+    private static boolean equalByRgs(RegistryTradingParams code, Registry rgs) {
         return code.equalByRegistry(
                 IEnumKey.getEnumByKey(RegistryDesignation.class, rgs.getRegistryDesignation()),
                 IEnumKey.getEnumByKey(RegistryInstrumentType.class, rgs.getRegistryInstrumentType()),

platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryDm_tClrnPredicate.java

@@ -0,0 +1,25 @@
+package ru.spcex.platform.imdg.api.predicate.specific;
+
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.RegistryTradingParams;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+
+import java.util.function.Function;
+
+public record RegistryDm_tClrnPredicate(Long companyId, Long counterPartyId) implements Function<Imdg<?>, ImdgPredicate> {
+
+    public static RegistryDm_tClrnPredicate instance(Long companyId, Long counterPartyId) {
+        return new RegistryDm_tClrnPredicate(companyId, counterPartyId);
+    }
+
+    @Override
+    public ImdgPredicate apply(Imdg<?> registryImdg) {
+        String sqlCondition = String.format("(%s) and accountType='%s' and companyId = %d and counterPartyId = %d",
+                RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.DM_T).build(),
+                AccountType.Clrn.getKey(),
+                companyId,
+                counterPartyId);
+        return registryImdg.predicateBuilder().sql(sqlCondition);
+    }
+}