CS_BLKD

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/PaymentInstructionBuilderV2.java

@@ -14,6 +14,9 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.enumeration.*;
 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.api.predicate.specific.RegistryCodeSqlBuilder;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.time.TimeUtil;
 
@@ -21,6 +24,7 @@ import java.math.BigDecimal;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
+import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicLong;
 
@@ -30,6 +34,7 @@ public class PaymentInstructionBuilderV2 {
     private ImdgProvider imdgProvider;
     private Imdg<Company> companyImdg;
     private Imdg<CompanySymbols> companySymbolsImdg;
+    private Imdg<Registry> rgsImdg;
     private final Imdg<ClearingMemberCategory> clearingCategoryImdg;
     private final Imdg<CompanyRoleSet> cmpRoleImdg;
     private Long sessionId;
@@ -44,6 +49,8 @@ public class PaymentInstructionBuilderV2 {
     private Long addresseeId;
     private boolean useCS_BLKD = false;
 
+    private Registry am_b;
+
     public static PaymentInstructionBuilderV2 builder(ImdgProvider imdgProvider) {
         return new PaymentInstructionBuilderV2(imdgProvider);
     }
@@ -52,12 +59,17 @@ public class PaymentInstructionBuilderV2 {
         this.imdgProvider = imdgProvider;
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
+        this.rgsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.clearingCategoryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class);
         this.cmpRoleImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class);
     }
 
-    public PaymentInstructionBuilderV2 useCS_BLKD(boolean useCS_BLKD) {
+    public PaymentInstructionBuilderV2 checkBLKD(Registry rgs) {
-        this.useCS_BLKD = useCS_BLKD;
+        if (rgs == null) {
+            return this;
+        }
+        this.useCS_BLKD = true;
+        this.am_b = rgs;
         return this;
     }
 
@@ -142,8 +154,8 @@ public class PaymentInstructionBuilderV2 {
             payment.setSettlementDate(LocalDate.now());
         }
 
-        if (useCS_BLKD && categoryVInitiator(senderId) && companyRoleODEPPresent(senderId)) {
+        if (useCS_BLKD && checkAgent()) {
-            payment.setPaymentPurpose(SpecifFlag.CS_BLKD.getKey() + " " + purpose);
+            payment.setPaymentPurpose(SpecifFlag.CS_BLKD.getKey() + "_" + sessionId + " " + purpose);
         } else {
             payment.setPaymentPurpose(purpose);
         }
@@ -212,6 +224,26 @@ public class PaymentInstructionBuilderV2 {
         }
     }
 
+    private boolean checkAgent() {
+        ImdgPredicateBuilder pb = rgsImdg.predicateBuilder();
+        ImdgPredicate prdct = pb.and(
+                pb.equals("sessionId", sessionId),
+                pb.sql(RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.CM__).build()),
+                pb.equals("companyId", addresseeId),
+                pb.equals("accountId", am_b.getAccountId())
+        );
+        Collection<Registry> claims = rgsImdg.getCollectionObjectsByPredicate(prdct);
+        boolean hasCounterPartyInitiator = false;
+        for (Registry claim : claims) {
+            Long counterPartyId = claim.getCounterPartyId();
+            if (categoryVInitiator(counterPartyId) && companyRoleODEPPresent(counterPartyId)) {
+                hasCounterPartyInitiator = true;
+                break;
+            }
+        }
+        return hasCounterPartyInitiator;
+    }
+
     public boolean categoryVInitiator(Long companyId) {
         ClearingMemberCategory category = clearingCategoryImdg.getFirstObjectByFieldValues(
                 Map.of("companyId", companyId));

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java

@@ -48,6 +48,7 @@ import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.log.ExceptionUtils;
 import ru.spcex.platform.utils.text.TextUtil;
 import ru.spcex.platform.utils.validation.IValidator;
 
@@ -62,6 +63,7 @@ import java.util.Optional;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static ru.spcex.platform.enumeration.RegistryTradingParams.D__V;
@@ -361,13 +363,13 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
                         if (TextUtil.isEmpty(asts.a__t().getTradingClearingRegistry())) {
                             log.trace("stmt.id={} {}.id={} TCR is empty, skipping gateway request",
                                     stmt.getId(), asts.a__t().getRegistryCode(), asts.a__t().getId());
-                        } else if (TextUtil.isEmpty(sdf57.getSpecif())
+                        } else {
-                                || !sdf57.getSpecif().contains(SpecifFlag.CS_BLKD.getKey())) {
                             log.trace("sending gateway request for stmt.id={}", stmt.getId());
-                            kafka.sendRequestToQueue(Consts.ASSET_OPERATION,
+                            Optional<AssetOperationListRequest> gtwReq = gatewayRequest(stmt,
-                                    gatewayRequest(stmt,
+                                    company,
-                                            company.getTradingCode(),
+                                    account,
-                                            asts.a__t().getTradingClearingRegistry()));
+                                    asts.a__t().getTradingClearingRegistry());
+                            gtwReq.ifPresent(r -> kafka.sendRequestToQueue(Consts.ASSET_OPERATION, r));
                         }
                     }
                     return Optional.of(asts);
@@ -735,25 +737,56 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
         R apply(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    private AssetOperationListRequest gatewayRequest(Statement stmt, String tradingCode, String tcrCode) {
+    private static final Pattern csBlkd = Pattern.compile(SpecifFlag.CS_BLKD.getKey() + "_(\\d+).*");
+
+    private Optional<AssetOperationListRequest> gatewayRequest(Statement stmt, Company company, Account account, String tcrCode) {
+        if (AccountType.Anlt.equalsByKey(account.getAccountType())) {
+            return Optional.empty();
+        }
+        String tradingCode = company.getTradingCode();
         AssetOperationListRequest gatewayRequest = new AssetOperationListRequest();
         AssetOperationRequest req = GatewayRequestCreator.from(stmt, tradingCode, tcrCode);
-        Session existActiveSession = sessionImdg.getFirstObjectByFieldValues(Map.of(
+        String specif = stmt.getComment();
-                "workflowStatus", SessionStatus.ACTV.getKey()
+
-        ));
+        Matcher m;
-        if (existActiveSession != null) {
+        if (!TextUtil.isEmpty(specif) && (m = csBlkd.matcher(specif)).find()) {
-            log.debug("active session.id={} type {}", existActiveSession.getId(), existActiveSession.getSessionType());
+            try {
-            List<Registry> d__vs = assets.searchByParams(stmt.getAccount(), CurrencyCode.RUB.getKey(), stmt.getSenderId(), D__V)
+                Long sessionId = Long.valueOf(m.group(1));
-                    .stream()
+                List<Registry> d__vs = assets.searchByParams(account.getAccount(), CurrencyCode.RUB.getKey(), company.getId(), D__V)
-                    .filter(rgs -> existActiveSession.getId().equals(rgs.getSessionId()))
+                        .stream()
-                    .toList();
+                        .filter(rgs -> sessionId.equals(rgs.getSessionId()))
-            BigDecimal d__vSum = d__vs.stream()
+                        .toList();
-                .map(rgs -> safeBD(rgs.getBalance()))
+                BigDecimal d__vSum = d__vs.stream()
-                .reduce(BigDecimal.ZERO, BigDecimal::add);
+                        .map(rgs -> safeBD(rgs.getBalance()))
-            BigDecimal amount = req.getAmount();
+                        .reduce(BigDecimal.ZERO, BigDecimal::add);
-            req.setAmount(safeBD(amount).subtract(d__vSum));
+                BigDecimal amount = req.getAmount();
+                req.setAmount(safeBD(amount).subtract(d__vSum));
+            } catch (NumberFormatException e) {
+                log.error("stmt.id={} failed to parse specif {} {}",
+                        stmt.getId(),
+                        specif,
+                        ExceptionUtils.getStackTrace(e));
+            }
+        }
+        //Session existActiveSession = sessionImdg.getFirstObjectByFieldValues(Map.of(
+        //        "workflowStatus", SessionStatus.ACTV.getKey()
+        //));
+        //if (existActiveSession != null) {
+        //    log.debug("active session.id={} type {}", existActiveSession.getId(), existActiveSession.getSessionType());
+        //    List<Registry> d__vs = assets.searchByParams(stmt.getAccount(), CurrencyCode.RUB.getKey(), stmt.getSenderId(), D__V)
+        //            .stream()
+        //            .filter(rgs -> existActiveSession.getId().equals(rgs.getSessionId()))
+        //            .toList();
+        //    BigDecimal d__vSum = d__vs.stream()
+        //        .map(rgs -> safeBD(rgs.getBalance()))
+        //        .reduce(BigDecimal.ZERO, BigDecimal::add);
+        //    BigDecimal amount = req.getAmount();
+        //    req.setAmount(safeBD(amount).subtract(d__vSum));
+        //}
+        if (req.getAmount().compareTo(BigDecimal.ZERO) == 0) {
+            return Optional.empty();
         }
         gatewayRequest.setAssetOperationRequests(List.of(req));
-        return gatewayRequest;
+        return Optional.of(gatewayRequest);
     }
 }

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

@@ -215,7 +215,8 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
                     .creditLegAccount(creditLegAccount)
                     .amount(amount)
                     .sessionId(sessionId)
-                    .useCS_BLKD(SessionType.FINL.equals(sessionType) || SessionType.MEDM.equals(sessionType))
+                    .checkBLKD((SessionType.FINL.equals(sessionType) || SessionType.MEDM.equals(sessionType))
+                            && !isPositiveBalance ? registry : null)
                     .purpose(String.format("Перевод по итогу клиринга по ТКР %s", registry.getTradingClearingRegistry()));
             PaymentInstruction paymentInstruction = paymentInstructionBuilder.build();
             log.debug("Created paymentInstruction by registry.id: {}", registry.getId());
@@ -282,7 +283,6 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
                         .sender(senderId)
                         .addressee(addresseeId)
                         .debitLegAccount(debitLegAccount)
-                        .useCS_BLKD(SessionType.FINL.equals(sessionType) || SessionType.MEDM.equals(sessionType))
                         .creditLegAccount(creditLegAccount)
                         .amount(amount)
                         .sessionId(sessionId)