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

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

@@ -16,9 +16,11 @@ import ru.clearing.classes.statics.data.misc.Session;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.session.stage.TaskType;
+import ru.spcex.clearing.session.state.DataEnum;
 import ru.spcex.clearing.session.state.SsnEvent;
 import ru.spcex.clearing.session.state.action.CreateSessionAction;
 import ru.spcex.clearing.session.state.action.DealsPrepareAction;
+import ru.spcex.clearing.session.state.action.DiscardRegistriesAction;
 import ru.spcex.clearing.session.state.action.EndStageNotificationAction;
 import ru.spcex.clearing.session.state.action.FinishingSessionAction;
 import ru.spcex.clearing.session.state.action.FormingPaymentInstructionAssetsAction;
@@ -29,14 +31,18 @@ import ru.spcex.clearing.session.state.action.InspectionObligationsV2Action;
 import ru.spcex.clearing.session.state.action.ObligationAdmissionAction;
 import ru.spcex.clearing.session.state.action.RequirementAndObligationCreationAction;
 import ru.spcex.clearing.session.state.action.ReviseStage1;
+import ru.spcex.clearing.session.state.action.SaveRegistriesAndContinueAction;
 import ru.spcex.clearing.session.state.action.Sdf56Action;
 import ru.spcex.clearing.session.state.action.SdfReceivedAction;
 import ru.spcex.clearing.session.state.guard.PaymentsWereCreatedGuard;
 import ru.spcex.clearing.session.state.guard.PaymentsWereNotCreatedGuard;
 import ru.spcex.clearing.session.state.guard.SdfGuard;
 import ru.spcex.clearing.session.state.guard.SdfGuardExtractorAfterAssets;
+import ru.spcex.clearing.session.state.guard.StashedRegistriesPresentGuard;
 import ru.spcex.clearing.session.state.listener.MachineMonitoringListener;
 import ru.spcex.clearing.util.StateMachineUtil;
+import static ru.spcex.clearing.util.StateMachineUtil.chain;
+import static ru.spcex.clearing.util.StateMachineUtil.invert;
 import ru.spcex.platform.classes.base.interfaces.ExecutionType;
 import ru.spcex.platform.enumeration.RegistryStatus;
 import ru.spcex.platform.enumeration.Section;
@@ -63,6 +69,12 @@ public class FinalSessionStateMachineConfig
     private final FormingPaymentInstructionAssetsAction formingPaymentInstructionAssetsAction;
     private final FinishingSessionAction finishingSessionAction;
     private final EndStageNotificationAction endStageNotificationAction;
+    private final SaveRegistriesAndContinueAction obligationAdmissionContinueAction;
+    private final DiscardRegistriesAction discardOblAdmStash =
+        new DiscardRegistriesAction(DataEnum.obligationAdmissionStashedRgs);
+    private final StashedRegistriesPresentGuard oblAdmGuard = new StashedRegistriesPresentGuard(
+        DataEnum.obligationAdmissionStashedRgs
+    );
 
     private final SessionType SESSION_TYPE = SessionType.FINL;
     private final Section SECTION = Section.MKR;
@@ -81,10 +93,11 @@ public class FinalSessionStateMachineConfig
         InspectionObligationsV2Action inspectionObligationsV2Action,
         FormingPaymentInstructionReturnMkrAction formingPaymentInstructionReturnMkrAction,
         FormingPaymentInstructionAssetsAction formingPaymentInstructionAssetsAction,
-        FinishingSessionAction finishingSessionAction, EndStageNotificationAction endStageNotificationAction
+        FinishingSessionAction finishingSessionAction, EndStageNotificationAction endStageNotificationAction, SaveRegistriesAndContinueAction obligationAdmissionContinueAction
     ) {
         this.sendSdf56Action = sendSdf56Action;
         this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
+        this.obligationAdmissionContinueAction = obligationAdmissionContinueAction;
         Imdg<Registry> rgsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.reviseStage1Action = reviseStage1Action;
         this.dealsPrepareAction = dealsPrepareAction;
@@ -115,13 +128,14 @@ public class FinalSessionStateMachineConfig
         );
         this.inspOblDepositReturnAction.setSessionType(SESSION_TYPE);
         this.inspectionObligationsV2Action.setSessionType(SESSION_TYPE);
+        this.obligationAdmissionContinueAction.setDataEnum(DataEnum.obligationAdmissionStashedRgs);
     }
 
     @Override
     public void configure(StateMachineStateConfigurer<TaskType, SsnEvent> states) throws Exception {
         states
             .withStates()
-            .initial(TaskType.StartRevise, StateMachineUtil.chain(
+            .initial(TaskType.StartRevise, chain(
                 new CreateSessionAction(sessionImdg)
                     .sessionType(SESSION_TYPE)
                     .section(SECTION),
@@ -134,13 +148,12 @@ public class FinalSessionStateMachineConfig
                 TaskType.ObligationsAdmission,
                 TaskType.InclusionToPool,
                 TaskType.InspectionObligations,
-                TaskType.InspectionObligations,
                 TaskType.FormingRegistersOnOS,
                 TaskType.FormingPaymentInstruction,
-                TaskType.FormingPaymentInstruction,
                 TaskType.FinishingSession,
                 TaskType.EndStageNotification,
-                TaskType.PSEUDO_waitingForSdf
+                TaskType.PSEUDO_waitingForSdf,
+                TaskType.PSEUDO_waitingForObligationAdmission
             )))
             .end(TaskType.EndStageNotification);
     }
@@ -166,9 +179,25 @@ public class FinalSessionStateMachineConfig
                 .source(TaskType.RequirementsAndObligationsCreate).target(TaskType.ObligationsAdmission)
                 .action(obligationAdmissionAction)
                 .and()
+            .withExternal()
+                .source(TaskType.ObligationsAdmission)
+                .target(TaskType.PSEUDO_waitingForObligationAdmission)
+                .guard(oblAdmGuard)
+                .and()
+            .withExternal()
+                .source(TaskType.PSEUDO_waitingForObligationAdmission).target(TaskType.InclusionToPool)
+                .action(chain(obligationAdmissionContinueAction, inclusionToPoolAction))
+                .event(SsnEvent.CONTINUE)
+                .and()
+            .withExternal()
+                .source(TaskType.PSEUDO_waitingForObligationAdmission).target(TaskType.ObligationsAdmission)
+                .action(StateMachineUtil.chain(discardOblAdmStash, obligationAdmissionAction))
+                .event(SsnEvent.REPEAT)
+                .and()
             .withExternal()
                 .source(TaskType.ObligationsAdmission).target(TaskType.InclusionToPool)
-                .action(inclusionToPoolAction)
+                .guard(invert(oblAdmGuard))
+                .action(chain(obligationAdmissionContinueAction, inclusionToPoolAction))
                 .and()
             .withExternal()
                 .source(TaskType.InclusionToPool).target(TaskType.InspectionObligations)
@@ -219,7 +248,6 @@ public class FinalSessionStateMachineConfig
         config
             .withConfiguration()
             .machineId(SESSION_TYPE.getKey())
-            .listener(loggingChangeStateListener)
+            .listener(loggingChangeStateListener);
-        ;
     }
 }

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

@@ -56,7 +56,8 @@ public enum TaskType implements IEnumKey {
      * Step 11
      */
     EndStageNotification("CL11"),
-    PSEUDO_waitingForSdf("PSEUDO_waitingForSdf")
+    PSEUDO_waitingForSdf("PSEUDO_waitingForSdf"),
+    PSEUDO_waitingForObligationAdmission("PSEUDO_waitingForObligationAdmission"),
     ;
 
     private String key;

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

@@ -7,7 +7,7 @@ public enum DataEnum {
     session, //Session
     dealsPrepared, //List<ExecutionCommon>
     counterPartyId, //Long
-
+    obligationAdmissionStashedRgs, //Map<Long, Registry>
     paymentInstructionReturnMkr, //List<PaymentInstruction>
     paymentInfo,
 }

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

@@ -4,4 +4,7 @@ public enum SsnEvent {
     SDF_01,
     SDF_57,
     SDF_04,
+    PAUSE,
+    CONTINUE,
+    REPEAT
 }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/action/DiscardRegistriesAction.java

@@ -0,0 +1,22 @@
+package ru.spcex.clearing.session.state.action;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.statemachine.StateContext;
+import ru.spcex.clearing.session.stage.TaskType;
+import ru.spcex.clearing.session.state.DataEnum;
+import ru.spcex.clearing.session.state.SsnEvent;
+
+public class DiscardRegistriesAction extends AbstractSessionActionForOkErrorHandling {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final DataEnum dataEnum;
+
+    public DiscardRegistriesAction(DataEnum dataEnum) {
+        this.dataEnum = dataEnum;
+    }
+
+    @Override
+    protected void actualExecute(StateContext<TaskType, SsnEvent> ctx) {
+        ctx.getExtendedState().getVariables().remove(dataEnum);
+    }
+}

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/action/ObligationAdmissionAction.java

@@ -66,12 +66,12 @@ public class ObligationAdmissionAction extends AbstractSessionActionForOkErrorHa
     @Override
     protected void actualExecute(StateContext<TaskType, SsnEvent> ctx) {
         try (cash) {
-            Long sessionId = ctx.getExtendedState().get(DataEnum.sessionId, Long.class);
+            obligationAdmission(ctx);
-            obligationAdmission(sessionId);
         }
     }
 
-    private void obligationAdmission(Long sessionId) {
+    private void obligationAdmission(StateContext<TaskType, SsnEvent> ctx) {
+        Long sessionId = ctx.getExtendedState().get(DataEnum.sessionId, Long.class);
         Collection<Registry> registries = registryImdg.getCollectionObjectsBySQL("sessionId = " + sessionId);
         Map<Long, List<Registry>> byGroups = registries.stream().collect(Collectors.groupingBy(Registry::getGroupId));
         log.info("found {} ({} groups) registries with sessionId {}", registries.size(), byGroups.size(), sessionId);
@@ -95,7 +95,12 @@ public class ObligationAdmissionAction extends AbstractSessionActionForOkErrorHa
                 }
             }
         }
-        registryImdg.putAll(rgsToUpdate);
+
+        ctx.getExtendedState().getVariables().put(DataEnum.obligationAdmissionStashedRgs, rgsToUpdate);
+//        if (wasNack) {
+//        } else {
+//            registryImdg.putAll(rgsToUpdate);
+//        }
     }
 
     private IValidator valFor(Registry rgs) {

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/action/SaveRegistriesAndContinueAction.java

@@ -0,0 +1,41 @@
+package ru.spcex.clearing.session.state.action;
+
+import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.context.annotation.Scope;
+import org.springframework.statemachine.StateContext;
+import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+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.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+@Service
+@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+public class SaveRegistriesAndContinueAction extends AbstractSessionActionForOkErrorHandling {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final Imdg<Registry> registryImdg;
+    private DataEnum dataEnum;
+
+    @Autowired
+    public SaveRegistriesAndContinueAction(ImdgProvider imdgProvider) {
+        this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+    }
+
+    public void setDataEnum(DataEnum dataEnum) {
+        this.dataEnum = dataEnum;
+    }
+
+    @Override
+    protected void actualExecute(StateContext<TaskType, SsnEvent> ctx) {
+        @SuppressWarnings("unchecked")
+        Map<Long, Registry> rgss = ctx.getExtendedState().get(dataEnum, Map.class);
+        registryImdg.putAll(rgss, 200);
+    }
+}

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

@@ -0,0 +1,24 @@
+package ru.spcex.clearing.session.state.guard;
+
+import java.util.Map;
+import org.springframework.statemachine.StateContext;
+import org.springframework.statemachine.guard.Guard;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.spcex.clearing.session.stage.TaskType;
+import ru.spcex.clearing.session.state.DataEnum;
+import ru.spcex.clearing.session.state.SsnEvent;
+
+public class StashedRegistriesPresentGuard implements Guard<TaskType, SsnEvent> {
+    private final DataEnum dataEnum;
+
+    public StashedRegistriesPresentGuard(DataEnum dataEnum) {
+        this.dataEnum = dataEnum;
+    }
+
+    @Override
+    public boolean evaluate(StateContext<TaskType, SsnEvent> ctx) {
+        @SuppressWarnings("unchecked")
+        Map<Long, Registry> rgss = ctx.getExtendedState().get(dataEnum, Map.class);
+        return rgss != null && !rgss.isEmpty();
+    }
+}

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/util/StateMachineUtil.java

@@ -3,6 +3,7 @@ package ru.spcex.clearing.util;
 import org.springframework.statemachine.StateContext;
 import org.springframework.statemachine.StateMachine;
 import org.springframework.statemachine.action.Action;
+import org.springframework.statemachine.guard.Guard;
 
 public class StateMachineUtil {
 
@@ -18,6 +19,10 @@ public class StateMachineUtil {
         return getId(stateMachine);
     }
 
+    public static <T1, T2> Guard<T1, T2> invert(Guard<T1, T2> guard) {
+        return context -> !guard.evaluate(context);
+    }
+
     public static <S, A> Action<S, A> chain(Action<S, A> a, Action<S, A> b) {
         return context -> {
             a.execute(context);