http://jira.mfd.msk:8088/browse/CLS-290 stage 7

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/models/RegistryTradingParams.java

@@ -1,14 +1,23 @@
 package ru.spcex.clearing.models;
 
+import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.platform.enumeration.RegistryCapacity;
 import ru.spcex.platform.enumeration.RegistryDesignation;
 import ru.spcex.platform.enumeration.RegistryInstrumentType;
 import ru.spcex.platform.enumeration.RegistryUnit;
+import ru.spcex.platform.utils.enumeration.IEnumKey;
 
 public record RegistryTradingParams(RegistryDesignation registryDesignation,
                                     RegistryInstrumentType registryInstrumentType,
                                     RegistryCapacity registryCapacity,
                                     RegistryUnit registryUnit) {
 
+    public boolean equalByRegistry(Registry registry) {
+        boolean isEqualDesignation = this.registryDesignation == null || IEnumKey.getEnumByKey(RegistryDesignation.class, registry.getRegistryDesignation()) == this.registryDesignation;
+        boolean isEqualInstrumentType = this.registryInstrumentType == null || IEnumKey.getEnumByKey(RegistryInstrumentType.class, registry.getRegistryInstrumentType()) == this.registryInstrumentType;
+        boolean isEqualCapacity = this.registryCapacity == null || IEnumKey.getEnumByKey(RegistryCapacity.class, registry.getRegistryCapacity()) == this.registryCapacity;
+        boolean isEqualUnit = this.registryUnit == null || IEnumKey.getEnumByKey(RegistryUnit.class, registry.getRegistryUnit()) == this.registryUnit;
+        return isEqualDesignation && isEqualInstrumentType && isEqualCapacity && isEqualUnit;
+    }
 
 }

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

@@ -9,7 +9,7 @@ import java.util.stream.Collectors;
 
 public class RegistryCodeSqlBuilder {
 
-    private List<RegistryTradingParams> registryTradingParams = new ArrayList<>();
+    private List<RegistryTradingParams> registryTradingParams;
 
     public static RegistryCodeSqlBuilder getInstance(RegistryTradingParams... tradingParams) {
         return new RegistryCodeSqlBuilder(Arrays.asList(tradingParams));

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

@@ -6,9 +6,10 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.payment.PaymentInstruction;
 import ru.clearing.classes.statics.data.registry.Registry;
-import ru.spcex.clearing.error.ClearingError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.models.RegistryTradingParams;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.clearing.service.builder.sql.RegistryCodeSqlBuilder;
 import ru.spcex.clearing.session.stage.ISessionStage;
 import ru.spcex.clearing.session.stage.StageResult;
 import ru.spcex.clearing.session.stage.Task;
@@ -19,16 +20,12 @@ import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgId;
 import ru.spcex.platform.imdg.api.ImdgProvider;
-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.enumeration.SimpleMessageResolver;
 
-import java.util.ArrayList;
+import java.math.BigDecimal;
 import java.util.Collection;
 import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
 
 @Service
 public class FormingPaymentInstruction implements ISessionStage {
@@ -64,64 +61,137 @@ public class FormingPaymentInstruction implements ISessionStage {
 
 
     private StageResult inspectionPool(Long processedCompanyId) {
-        String sqlCondition = String.format("registryDesignation in ('%s', '%s') and " +
+        RegistryTradingParams registryTradingParamsL = new RegistryTradingParams(RegistryDesignation.L,
-                        "registryInstrumentType in ('%s', '%s') and " +
+                RegistryInstrumentType.S, null, RegistryUnit.T);
-                        "registryUnit = '%s' and " +
+        RegistryTradingParams registryTradingParamsC = new RegistryTradingParams(RegistryDesignation.C,
-                        "registryStatus = '%s' and " +
+                RegistryInstrumentType.M, null, null);
-                        "settlementDate = '%s'",
+        RegistryCodeSqlBuilder registryCodeSqlBuilder = RegistryCodeSqlBuilder.getInstance(registryTradingParamsL, registryTradingParamsC);
-                RegistryDesignation.O.getKey(), RegistryDesignation.T.getKey(),
+        String registryCodeCondition = registryCodeSqlBuilder.build();
-                RegistryInstrumentType.S.getKey(), RegistryInstrumentType.M.getKey(),
-                RegistryUnit.T.getKey(),
-                "POOL");
 
-        Collection<Registry> obligations = registryImdg.getCollectionObjectsBySQL(sqlCondition);
+        Collection<Registry> obligations = registryImdg.getCollectionObjectsBySQL(registryCodeCondition);
-        Map<Long, Map<Long, List<Registry>>> registryByGroupIdAndCompanyId = obligations.stream().
-                collect(Collectors.groupingBy(Registry::getGroupId, Collectors.groupingBy(Registry::getCompanyId)));
 
-        List<Long> insecurityGroups = new ArrayList<>();
+        List<Registry> obligationsByMoney = obligations.stream().filter(registry ->
-        for (Registry currentRegistry : obligations) {
+                        new RegistryTradingParams(RegistryDesignation.L, RegistryInstrumentType.M, null, RegistryUnit.T).equalByRegistry(registry))
-            if (insecurityGroups.contains(currentRegistry.getGroupId())) {
+                .toList();
-                log.debug("Skip insecurity groupId: {}", currentRegistry.getGroupId());
+
-                continue;
+        for (Registry obligationByMoney : obligationsByMoney) {
-            }
+            String sql = String.format("tradingClearingRegistryId = %s and companyId = %s",
-            if (IEnumKey.getEnumByKey(RegistryDesignation.class, currentRegistry.getRegistryDesignation()) == RegistryDesignation.A) {
+                    obligationByMoney.getTradingClearingRegistryId(), obligationByMoney.getCompanyId());
-                String sqlCounterRegistryCondition = String.format("registryDesignation = '%s' and " +
+            Collection<Registry> relatedRegistries = registryImdg.getCollectionObjectsBySQL(sql);
-                                "registryInstrumentType in ('%s', '%s') and " +
+
-                                "registryUnit = '%s' and " +
+            RegistryTradingParams registryTradingParamsF = new RegistryTradingParams(RegistryDesignation.A,
-                                "tradingClearingRegistryId = '%s' and " +
+                    RegistryInstrumentType.M, null, RegistryUnit.F);
-                                "companyId = '%s' and ",
+            RegistryTradingParams registryTradingParamsT = new RegistryTradingParams(RegistryDesignation.A,
-                        RegistryDesignation.A,
+                    RegistryInstrumentType.M, null, RegistryUnit.T);
-                        RegistryInstrumentType.S.getKey(), RegistryInstrumentType.M.getKey(),
+            RegistryTradingParams registryTradingParamsB = new RegistryTradingParams(RegistryDesignation.A,
-                        RegistryUnit.F.getKey(),
+                    RegistryInstrumentType.M, null, RegistryUnit.B);
-                        currentRegistry.getTradingClearingRegistryId(),
+
-                        currentRegistry.getCompanyId());
+            for (Registry relatedRegistry : relatedRegistries) {
-                Registry counterRegistry = registryImdg.getSingleObjectBySQL(sqlCounterRegistryCondition);
+                if (registryTradingParamsF.equalByRegistry(relatedRegistry)) {
-                if (currentRegistry.getBalance().compareTo(counterRegistry.getBalance()) > 0) {
+                    relatedRegistry.setBalance(relatedRegistry.getBalance().subtract(obligationByMoney.getBalance()));
-                    log.warn("{}", msgResolver.resolve(new EnumMessage(ClearingError.InsecurityObligation, currentRegistry.getCompanyId())));
+                } else if (registryTradingParamsT.equalByRegistry(relatedRegistry)) {
-                    insecurityGroups.add(currentRegistry.getGroupId());
+                    relatedRegistry.setSettledDebit(relatedRegistry.getSettledDebit().add(obligationByMoney.getBalance()));
-                    break;
+                } else if (registryTradingParamsB.equalByRegistry(relatedRegistry)) {
+                    relatedRegistry.setBalance(relatedRegistry.getBalance().add(obligationByMoney.getBalance()));
                 }
-                currentRegistry.setRegistryStatus("OK");
+                registryImdg.update(relatedRegistry);
-                registryImdg.update(counterRegistry);
             }
         }
 
-        for (Long insecuritiesGroupId : insecurityGroups) {
+        List<Registry> requirementsByIssue = obligations.stream().filter(registry ->
-            for (Map.Entry<Long, List<Registry>> entrySet : registryByGroupIdAndCompanyId.get(insecuritiesGroupId).entrySet()) {
+                        new RegistryTradingParams(RegistryDesignation.C, RegistryInstrumentType.S, null, RegistryUnit.T).equalByRegistry(registry))
-                if (entrySet.getKey().equals(processedCompanyId)) {
+                .toList();
-                    for (Registry registry : entrySet.getValue()) {
+
-                        registry.setRegistryStatus("UNCV");
+        for (Registry requirementByIssue : requirementsByIssue) {
-                        registryImdg.update(registry);
+            String sql = String.format("tradingClearingRegistryId = %s and companyId = %s",
-                    }
+                    requirementByIssue.getTradingClearingRegistryId(), requirementByIssue.getCompanyId());
-                } else {
+            Collection<Registry> relatedRegistries = registryImdg.getCollectionObjectsBySQL(sql);
-                    for (Registry registry : entrySet.getValue()) {
+
-                        registry.setRegistryStatus("FAIL");
+            RegistryTradingParams registryTradingParamsA = new RegistryTradingParams(RegistryDesignation.A,
-                        registryImdg.update(registry);
+                    RegistryInstrumentType.S, null, RegistryUnit.T);
-                    }
+
+            for (Registry relatedRegistry : relatedRegistries) {
+                if (registryTradingParamsA.equalByRegistry(relatedRegistry)) {
+                    relatedRegistry.setSettledDebit(relatedRegistry.getSettledDebit().add(requirementByIssue.getBalance()));
                 }
+                registryImdg.update(relatedRegistry);
             }
         }
 
+        List<Registry> requirementsByMoney = obligations.stream().filter(registry ->
+                        new RegistryTradingParams(RegistryDesignation.C, RegistryInstrumentType.M, null, RegistryUnit.T).equalByRegistry(registry))
+                .toList();
+
+        for (Registry requirementByMoney : requirementsByMoney) {
+            String sql = String.format("tradingClearingRegistryId = %s and companyId = %s",
+                    requirementByMoney.getTradingClearingRegistryId(), requirementByMoney.getCompanyId());
+            Collection<Registry> relatedRegistries = registryImdg.getCollectionObjectsBySQL(sql);
+
+            RegistryTradingParams registryTradingParamsA = new RegistryTradingParams(RegistryDesignation.A,
+                    RegistryInstrumentType.M, null, RegistryUnit.T);
+
+            for (Registry relatedRegistry : relatedRegistries) {
+                if (registryTradingParamsA.equalByRegistry(relatedRegistry)) {
+                    relatedRegistry.setSettledDebit(relatedRegistry.getSettledDebit().add(requirementByMoney.getBalance()));
+                }
+                registryImdg.update(relatedRegistry);
+            }
+        }
+
+        List<Registry> obligationsByIssue = obligations.stream().filter(registry ->
+                        new RegistryTradingParams(RegistryDesignation.L, RegistryInstrumentType.S, null, RegistryUnit.T).equalByRegistry(registry))
+                .toList();
+
+        for (Registry obligationByIssue : obligationsByIssue) {
+            String sql = String.format("tradingClearingRegistryId = %s and companyId = %s",
+                    obligationByIssue.getTradingClearingRegistryId(), obligationByIssue.getCompanyId());
+            Collection<Registry> relatedRegistries = registryImdg.getCollectionObjectsBySQL(sql);
+
+            RegistryTradingParams registryTradingParamsF = new RegistryTradingParams(RegistryDesignation.A,
+                    RegistryInstrumentType.S, null, RegistryUnit.F);
+            RegistryTradingParams registryTradingParamsT = new RegistryTradingParams(RegistryDesignation.A,
+                    RegistryInstrumentType.S, null, RegistryUnit.T);
+            RegistryTradingParams registryTradingParamsB = new RegistryTradingParams(RegistryDesignation.A,
+                    RegistryInstrumentType.S, null, RegistryUnit.B);
+
+            for (Registry relatedRegistry : relatedRegistries) {
+                if (registryTradingParamsF.equalByRegistry(relatedRegistry)) {
+                    relatedRegistry.setBalance(relatedRegistry.getBalance().subtract(obligationByIssue.getBalance()));
+                } else if (registryTradingParamsT.equalByRegistry(relatedRegistry)) {
+                    relatedRegistry.setSettledDebit(relatedRegistry.getSettledDebit().add(obligationByIssue.getBalance()));
+                } else if (registryTradingParamsB.equalByRegistry(relatedRegistry)) {
+                    relatedRegistry.setBalance(relatedRegistry.getBalance().add(obligationByIssue.getBalance()));
+                }
+                registryImdg.update(relatedRegistry);
+            }
+        }
+
+        for (Registry obligation : obligations) {
+            RegistryTradingParams registryTradingParamsLT = new RegistryTradingParams(RegistryDesignation.L,
+                    null, null, RegistryUnit.T);
+            registryCodeCondition = RegistryCodeSqlBuilder.getInstance(registryTradingParamsLT).build();
+            String sqlCondition = String.format("(%s) and securityId = %s and tradingClearingRegistryId = %s and companyId = %s and counterPartyId = %s",
+                    registryCodeCondition, obligation.getSecurityId(), obligation.getTradingClearingRegistryId(), obligation.getCompanyId(), obligation.getCounterPartyId());
+            Collection<Registry> registries = registryImdg.getCollectionObjectsBySQL(registryCodeCondition);
+
+            BigDecimal sumBalance = registries.stream().map(Registry::getBalance).reduce(BigDecimal.ZERO, BigDecimal::add);
+            PaymentInstruction paymentInstruction = createPaymentInstruction(obligation, sumBalance);
+            paymentInstructionImdg.insert(paymentInstruction);
+            obligation.setPaymentId(paymentInstruction.getId());
+            registryImdg.update(obligation);
+        }
+
+
+        //todo send message to queue for forming sDf03 and sDf12?
+
         return new StageResult(null, true);
     }
+
+    private PaymentInstruction createPaymentInstruction(Registry registry, BigDecimal balance){
+        PaymentInstruction paymentInstruction = new PaymentInstruction();
+        paymentInstruction.setSenderId(registry.getCompanyId());
+        paymentInstruction.setAddresseeId(registry.getCounterPartyId());
+        //todo add builder for paymentInstruction
+        return paymentInstruction;
+    }
 }

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

@@ -67,7 +67,6 @@ public class InclusionObligations implements ISessionStage {
                 sessionType);
         Collection<Registry> obligations = registryImdg.getCollectionObjectsBySQL(sqlCondition);
         Map<Long, List<Registry>> registryByGroupId = obligations.stream().
-                filter(registry -> registry.getCompanyId().equals(counterPartyId)).
                 collect(Collectors.groupingBy(Registry::getGroupId));
 
         for (Map.Entry<Long, List<Registry>> entrySet : registryByGroupId.entrySet()) {