http://jira.mfd.msk:8088/browse/CLS-290 1st step DealsPrepare conditions added

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

@@ -2,22 +2,29 @@ package ru.spcex.clearing.session.stage;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.InitializingBean;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.execution.ExecutionCommon;
+import ru.clearing.classes.statics.data.execution.ExecutionFond;
 import ru.clearing.classes.statics.data.misc.Session;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.session.stage.impl.*;
 import ru.spcex.clearing.session.stage.task.*;
+import ru.spcex.platform.classes.base.interfaces.ExecutionType;
+import ru.spcex.platform.enumeration.MarketType;
 import ru.spcex.platform.enumeration.Section;
 import ru.spcex.platform.enumeration.SessionStatus;
 import ru.spcex.platform.enumeration.SessionType;
+import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 
 import java.util.List;
 
 @Service
-public class PrimaryAuctionBnSession extends AbstractSession {
+public class PrimaryAuctionBnSession extends AbstractSession implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final BalanceRevise balanceRevise;
     private final DealsPrepare dealsPrepare;
@@ -31,6 +38,8 @@ public class PrimaryAuctionBnSession extends AbstractSession {
     private final FinishingSession finishingSession;
     private final EndStageNotification endStageNotification;
 
+    private final Imdg<ExecutionFond> executionFondImdg;
+
     public PrimaryAuctionBnSession(
             ImdgProvider imdgProvider,
             BalanceRevise balanceRevise,
@@ -53,6 +62,15 @@ public class PrimaryAuctionBnSession extends AbstractSession {
         this.unlockResources = unlockResources;
         this.finishingSession = finishingSession;
         this.endStageNotification = endStageNotification;
+        this.executionFondImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ExecutionFond, ExecutionFond.class);
+    }
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        dealsPrepare.searchForExecutions(ExecutionType.ExecutionFond);
+        ImdgPredicateBuilder execFondPb = executionFondImdg.predicateBuilder();
+        dealsPrepare.addExecutionFondCondition(execFondPb.regex("settlementCode", "^B[^0]\\d*$"));
+        dealsPrepare.addExecutionFondCondition(execFondPb.equals("marketType", MarketType.PRMR.getKey()));
     }
 
     public void runSession(BaseRequest<?> req) {

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

@@ -14,19 +14,17 @@ import ru.spcex.clearing.session.stage.ISessionStage;
 import ru.spcex.clearing.session.stage.StageResult;
 import ru.spcex.clearing.session.stage.Task;
 import ru.spcex.clearing.session.stage.task.DealsPreparePayload;
-import ru.spcex.platform.classes.base.interfaces.WithExchangeExecutionId;
+import ru.spcex.platform.classes.base.interfaces.ExecutionType;
 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 java.util.ArrayList;
-import java.util.Collection;
-import java.util.Comparator;
 import java.util.List;
 import java.util.function.BiFunction;
 import java.util.function.Function;
-import java.util.stream.Stream;
+import java.util.stream.Collectors;
 
 @Service
 @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@@ -36,6 +34,7 @@ public class DealsPrepare implements ISessionStage {
     private final Imdg<ExecutionFond> executionFondImdg;
     private final List<ImdgPredicate> execDepositPredicates = new ArrayList<>();
     private final List<ImdgPredicate> execFondPredicates = new ArrayList<>();
+    private ExecutionType executionType = ExecutionType.ExecutionFond;
 
     @Autowired
     public DealsPrepare(ImdgProvider imdgProvider) {
@@ -43,6 +42,10 @@ public class DealsPrepare implements ISessionStage {
         this.executionFondImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ExecutionFond, ExecutionFond.class);
     }
 
+    public void searchForExecutions(ExecutionType executionType) {
+        this.executionType = executionType;
+    }
+
     @Override
     public StageResult<?> submit(Task<?> task) {
         DealsPreparePayload payload = (DealsPreparePayload) task.getData();
@@ -73,14 +76,24 @@ public class DealsPrepare implements ISessionStage {
                 return pb.and(sqlPredicate, pb.and(imdgPredicates.toArray(new ImdgPredicate[0])));
             }
         };
-        ImdgPredicate excDepPrct = prdComposer.apply(execDepositPredicates, executionDepositImdg);
+        List<ExecutionCommon> excs;
-        ImdgPredicate excFondPrct = prdComposer.apply(execFondPredicates, executionFondImdg);
+        switch (executionType) {
-        Collection<ExecutionDeposit> excDpsts = executionDepositImdg.getCollectionObjectsByPredicate(excDepPrct);
+            case ExecutionDeposit -> {
-        Collection<ExecutionFond> excFonds = executionFondImdg.getCollectionObjectsByPredicate(excFondPrct);
+                ImdgPredicate excDepPrct = prdComposer.apply(execDepositPredicates, executionDepositImdg);
-        List<ExecutionCommon> excs = Stream.concat(excDpsts.stream().map(execToInterface()),
+                excs = executionDepositImdg.getCollectionObjectsByPredicate(excDepPrct)
-                        excFonds.stream().map(execToInterface()))
+                        .stream()
-                .sorted(Comparator.comparing(WithExchangeExecutionId::getExchangeExecutionId))
+                        .map(execToInterface())
-                .toList();
+                        .collect(Collectors.toList());
+            }
+            case ExecutionFond -> {
+                ImdgPredicate excFondPrct = prdComposer.apply(execFondPredicates, executionFondImdg);
+                excs = executionFondImdg.getCollectionObjectsByPredicate(excFondPrct)
+                        .stream()
+                        .map(execToInterface())
+                        .collect(Collectors.toList());
+            }
+            default -> throw new IllegalStateException("Unknown execution type: " + executionType);
+        }
         for (ExecutionCommon exc : excs) {
             exc.setSessionId(sessionId);
             if (exc instanceof ExecutionDeposit) {