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

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/UnitedSessionStateMachineConfig.java

@@ -1,7 +1,6 @@
 package ru.spcex.clearing.config.state_machine_2.specific;
 
 import java.util.Arrays;
-import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.List;
 import java.util.function.Supplier;
@@ -41,9 +40,8 @@ import ru.spcex.clearing.session.state.action.UpdateWorkflowStatusAction;
 import ru.spcex.clearing.session.state.guard.ErroneousRegistriesPresentGuard;
 import ru.spcex.clearing.session.state.guard.PaymentsWereCreatedGuard;
 import ru.spcex.clearing.session.state.guard.PaymentsWereNotCreatedGuard;
-import ru.spcex.clearing.session.state.guard.SdfGuardUtil;
+import ru.spcex.clearing.session.state.guard.SdfUnitSetGuardAfterPaymentInstructions;
-import ru.spcex.clearing.session.state.guard.SdfSetGuard;
+import ru.spcex.clearing.session.state.guard.SdfUnitSetGuardAfterRevise;
-import ru.spcex.clearing.session.state.guard.SdfUnitSetGuard;
 import ru.spcex.clearing.session.state.guard.StashedRegistriesPresentGuard;
 import ru.spcex.clearing.session.state.listener.MachineMonitoringListener;
 import static ru.spcex.clearing.util.StateMachineUtil.*;
@@ -215,14 +213,13 @@ public class UnitedSessionStateMachineConfig
     }
 
     private void sourcePseudoWaitAfterAgainRevise(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
-        EnumSet<SsnEvent> ssnEvents = SdfGuardUtil.afterAgainReviseError(SECTION);
         transitions
             .withExternal()
                 .source(TaskType.PSEUDO_waitSdfAfterAgainRevise)
                 .target(TaskType.AgainRevise)
-                .guard(new SdfSetGuard(ssnEvents))
+                .guard(new SdfUnitSetGuardAfterRevise())
                 .action(againRevise);
-        for (var event : ssnEvents) {
+        for (var event : SdfUnitSetGuardAfterRevise.supportedSdfs()) {
             transitions
                 .withInternal()
                 .source(TaskType.PSEUDO_waitSdfAfterAgainRevise)
@@ -325,14 +322,13 @@ public class UnitedSessionStateMachineConfig
     }
 
     private void sourcePseudoWaitSdfAfterPaymentInstructions(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
-        EnumSet<SsnEvent> sdfs = SdfGuardUtil.bySectionAfter7StepUnit();
         transitions
             .withExternal()
             .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions)
             .target(TaskType.AgainRevise)
-            .guard(new SdfUnitSetGuard(sdfs))
+            .guard(new SdfUnitSetGuardAfterPaymentInstructions())
             .action(againRevise);
-        for (var event: sdfs) {
+        for (var event: SdfUnitSetGuardAfterPaymentInstructions.supportedSdfs()) {
             transitions
                 .withInternal()
                 .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions)

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfGuardUtil.java

@@ -13,7 +13,7 @@ public class SdfGuardUtil {
                     SsnEvent.SDF_57
                 );
             }
-            case FOND, MULT -> {
+            case FOND -> {
                 return EnumSet.of(
                     SsnEvent.SDF_21,
                     SsnEvent.SDF_57
@@ -42,13 +42,4 @@ public class SdfGuardUtil {
             default -> throw new IllegalStateException("unknown wait conditions for section " + section);
         }
     }
-
-    public static EnumSet<SsnEvent> bySectionAfter7StepUnit() {
-        return EnumSet.of(
-            SsnEvent.SDF_04,
-            SsnEvent.SDF_57,
-            SsnEvent.SDF_13,
-            SsnEvent.SDF_21
-        );
-    }
 }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfUnitSetGuardAfterPaymentInstructions.java

@@ -4,7 +4,6 @@ import java.util.Collection;
 import java.util.EnumSet;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.statemachine.ExtendedState;
@@ -15,38 +14,42 @@ import ru.spcex.clearing.session.state.DataEnum;
 import ru.spcex.clearing.session.state.SsnEvent;
 import ru.spcex.platform.enumeration.SdfTable;
 
-public class SdfUnitSetGuard implements Guard<TaskType, SsnEvent> {
+public class SdfUnitSetGuardAfterPaymentInstructions implements Guard<TaskType, SsnEvent> {
     private final Logger log = LoggerFactory.getLogger(getClass());
-    private final EnumSet<SsnEvent> sdfs;
+    private final static EnumSet<SsnEvent> sdfsFullSet = EnumSet.of(
+        SsnEvent.SDF_04,
+        SsnEvent.SDF_57,
+        SsnEvent.SDF_13,
+        SsnEvent.SDF_21
+    );
 
-    public SdfUnitSetGuard(SsnEvent first, SsnEvent... rest) {
+    private final static EnumSet<SsnEvent> sdfsSmallSet = EnumSet.of(
-        this.sdfs = EnumSet.of(first, rest);
+        SsnEvent.SDF_04,
-    }
+        SsnEvent.SDF_57
+    );
 
-    public SdfUnitSetGuard(EnumSet<SsnEvent> sdfs) {
+    public static EnumSet<SsnEvent> supportedSdfs() {
-        this.sdfs = sdfs;
+        return EnumSet.copyOf(sdfsFullSet);
     }
 
     @Override
     public boolean evaluate(StateContext<TaskType, SsnEvent> ctx) {
         ExtendedState state = ctx.getExtendedState();
         @SuppressWarnings("unchecked")
-        Collection<SdfTable> sdfTables = ctx.getExtendedState().get(DataEnum.sdfTables, Collection.class);
+        Collection<SdfTable> sdfTables = state.get(DataEnum.sdfTables, Collection.class);
         Function<SsnEvent, Boolean> was = sdf -> state.get(sdf.name(), Object.class) != null;
 
-        boolean everySdfConditionMet;
+        EnumSet<SsnEvent> sdfs;
         if (sdfTables.contains(SdfTable.SDF_12)) {
-             everySdfConditionMet = sdfs
+            sdfs = sdfsFullSet;
-                .stream()
-                .allMatch(was::apply);
         } else {
-            everySdfConditionMet = Stream.of(SsnEvent.SDF_04, SsnEvent.SDF_57)
+            sdfs = sdfsSmallSet;
-                .allMatch(was::apply);
         }
+
+        boolean everySdfConditionMet = sdfs.stream().allMatch(was::apply);
         if (everySdfConditionMet) {
             log.info("all of {} conditions were met", sdfs);
-            sdfs.forEach(sdf -> state.getVariables().remove(sdf.name()));
+            sdfsFullSet.forEach(sdf -> state.getVariables().remove(sdf.name()));
-            sdfTables.forEach(sdfTable -> ctx.getExtendedState().getVariables().remove(sdfTable));
             return true;
         } else {
             log.info("conditions: {}",

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfUnitSetGuardAfterRevise.java

@@ -0,0 +1,61 @@
+package ru.spcex.clearing.session.state.guard;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.statemachine.ExtendedState;
+import org.springframework.statemachine.StateContext;
+import org.springframework.statemachine.guard.Guard;
+import ru.spcex.clearing.session.stage.TaskType;
+import ru.spcex.clearing.session.state.DataEnum;
+import ru.spcex.clearing.session.state.SsnEvent;
+import ru.spcex.platform.enumeration.SdfTable;
+
+public class SdfUnitSetGuardAfterRevise implements Guard<TaskType, SsnEvent> {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private static final EnumSet<SsnEvent> sdfsFullSet = EnumSet.of(
+        SsnEvent.SDF_21,
+        SsnEvent.SDF_57
+    );
+
+    private static final EnumSet<SsnEvent> sdfsSmallSet = EnumSet.of(
+        SsnEvent.SDF_57
+    );
+
+    public static EnumSet<SsnEvent> supportedSdfs() {
+        return EnumSet.copyOf(sdfsFullSet);
+    }
+
+    @Override
+    public boolean evaluate(StateContext<TaskType, SsnEvent> ctx) {
+        ExtendedState state = ctx.getExtendedState();
+        @SuppressWarnings("unchecked")
+        Collection<SdfTable> sdfTables = state.get(DataEnum.sdfTables, Collection.class);
+        Function<SsnEvent, Boolean> was = sdf -> state.get(sdf.name(), Object.class) != null;
+
+        EnumSet<SsnEvent> sdfs;
+        if (sdfTables.contains(SdfTable.SDF_12)) {
+            sdfs = sdfsFullSet;
+        } else {
+            sdfs = sdfsSmallSet;
+        }
+
+        boolean everySdfConditionMet = sdfs.stream().allMatch(was::apply);
+        if (everySdfConditionMet) {
+            log.info("all of {} conditions were met", sdfs);
+            sdfsFullSet.forEach(sdf -> state.getVariables().remove(sdf.name()));
+            return true;
+        } else {
+            log.info("conditions: {}",
+                sdfs
+                    .stream()
+                    .map(sdf -> "%s: %s".formatted(sdf.name(), was.apply(sdf) ? "received" : "waiting"))
+                    .collect(Collectors.joining(";", "[", "]"))
+                );
+            return false;
+        }
+    }
+}