treshenkov/clearing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

session state machine restore

Browse source
This commit is contained in:
ialbert 2025-07-29 13:54:40 +03:00
parent 6cce11d0ae
commit aaddaa5633
11 changed files with 174 additions and 120 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/CurrencySessionStateMachineConfig.java
View file

@ -149,6 +149,8 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure
TaskType.PSEUDO_waitSdfAfterPaymentInstructions,
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.PSEUDO_waitSdfAfterAgainRevise,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore,
TaskType.PSEUDO_waitAfterInspectionRestore,
TaskType.PSEUDO_waitAfterInspectionError
)))
.end(TaskType.FinishingSession);
@ -179,8 +181,8 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure
.action(inspectionObligationsV2Action);
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterIOError(transitions);
sourcePseudoAfterOAPause(transitions);
sourcePseudoAfterIOPause(transitions);
sourceFormingPaymentInstruction(transitions);
sourcePseudoWaitSdfAfterPaymentInstructions(transitions);
sourceAgainRevise(transitions);
@ -217,21 +219,23 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure
.action(chain(obligationAdmissionContinueAction, inclusionToPoolAction));
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after ObligationAdmission
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool)
.action(chain(activeWsAction, obligationAdmissionContinueAction, inclusionToPoolAction))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
private void sourcePseudoAfterIOError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterIOPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after InspectionObligations
.withExternal()
@ -239,12 +243,14 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure
.action(activeWsAction)
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(formingPaymentInstructionAssetsAction)
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterInspectionError).target(TaskType.InspectionObligations)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterInspectionError, TaskType.PSEUDO_waitAfterInspectionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.InspectionObligations)
.action(chain(activeWsAction, discardInspOblStash, inspectionObligationsV2Action))
.event(SsnEvent.REPEAT);
}
}
private void sourceFormingPaymentInstruction(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {

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

@ -4,6 +4,7 @@ import java.time.LocalDate;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Configuration;
@ -35,7 +36,6 @@ import ru.spcex.clearing.session.state.action.SaveRegistriesAfterInspectionAndCo
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.action.UpdateSessionStatusAction;
import ru.spcex.clearing.session.state.action.UpdateWorkflowStatusAction;
import ru.spcex.clearing.session.state.guard.ErroneousRegistriesPresentGuard;
import ru.spcex.clearing.session.state.guard.PaymentsWereCreatedGuard;
@ -77,7 +77,6 @@ public class FinalSessionStateMachineConfig
new DiscardRegistriesAction(DataEnum.obligationAdmissionStashedRgs);
private final UpdateWorkflowStatusAction pauseWsAction;
private final UpdateWorkflowStatusAction activeWsAction;
private final UpdateSessionStatusAction inspectionStatusAction;
private final DiscardRegistriesAction discardInspOblStash = new DiscardRegistriesAction(
DataEnum.inspectionObligationStashedRgs
);
@ -108,7 +107,7 @@ public class FinalSessionStateMachineConfig
SaveRegistriesAndContinueAction obligationAdmissionContinueAction,
SaveRegistriesAfterInspectionAndContinueAction saveRegistriesAfterInspectionAndContinueAction,
@Qualifier("pauseWorkflowStatusAction") UpdateWorkflowStatusAction pauseWsAction,
@Qualifier("activeWorkflowStatusAction") UpdateWorkflowStatusAction activeWsAction, UpdateSessionStatusAction inspectionStatusAction
@Qualifier("activeWorkflowStatusAction") UpdateWorkflowStatusAction activeWsAction
) {
this.sendSdf56Action = sendSdf56Action;
this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
@ -116,7 +115,6 @@ public class FinalSessionStateMachineConfig
this.saveRegistriesAfterInspectionAndContinueAction = saveRegistriesAfterInspectionAndContinueAction;
this.pauseWsAction = pauseWsAction;
this.activeWsAction = activeWsAction;
this.inspectionStatusAction = inspectionStatusAction.status(TaskType.InspectionObligations);
Imdg<Registry> rgsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.reviseStage1Action = reviseStage1Action;
this.dealsPrepareAction = dealsPrepareAction;
@ -165,9 +163,12 @@ public class FinalSessionStateMachineConfig
TaskType.FinishingSession,
TaskType.PSEUDO_waitSdfAfterPaymentInstructions,
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.PSEUDO_InspectionObligationDepositReturn,
TaskType.InspectionObligationDepositReturn,
TaskType.PSEUDO_waitAfterInspectionError,
TaskType.PSEUDO_waitAfterInspectionDepositReturnError
TaskType.PSEUDO_waitAfterInspectionDepositReturnError,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore,
TaskType.PSEUDO_waitAfterInspectionRestore,
TaskType.PSEUDO_waitAfterInspectionDepositReturnRestore
)))
.end(TaskType.FinishingSession);
}
@ -194,16 +195,16 @@ public class FinalSessionStateMachineConfig
.action(obligationAdmissionAction)
.and()
.withExternal()
.source(TaskType.InclusionToPool).target(TaskType.PSEUDO_InspectionObligationDepositReturn)
.source(TaskType.InclusionToPool).target(TaskType.InspectionObligationDepositReturn)
//нужно сменить статус ручками, т.к. псевдо состояние
.action(chain(inspectionStatusAction, inspOblDepositReturnAction));
.action(inspOblDepositReturnAction);
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterOAPause(transitions);
sourceIODepositReturn(transitions);
sourceIODepositReturnError(transitions);
sourceIODepositReturnPause(transitions);
sourceIO(transitions);
sourceIOError(transitions);
sourceIOPause(transitions);
sourceFormingPaymentInstruction(transitions);
sourcePseudoWaitSdfAfterPaymentInstructions(transitions);
}
@ -225,20 +226,20 @@ public class FinalSessionStateMachineConfig
private void sourceIODepositReturn(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
.withExternal()
.source(TaskType.PSEUDO_InspectionObligationDepositReturn)
.source(TaskType.InspectionObligationDepositReturn)
.target(TaskType.PSEUDO_waitAfterInspectionDepositReturnError)
.guard(inspErrGuard)
.action(pauseWsAction)
.and()
.withExternal()
.source(TaskType.PSEUDO_InspectionObligationDepositReturn)
.source(TaskType.InspectionObligationDepositReturn)
.target(TaskType.InspectionObligations)
.guard(invert(inspErrGuard))
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(inspectionObligationsV2Action);
}
private void sourceIODepositReturnError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourceIODepositReturnPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after InspectionObligations
.withExternal()
@ -246,12 +247,14 @@ public class FinalSessionStateMachineConfig
.action(activeWsAction)
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(inspectionObligationsV2Action)
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterInspectionDepositReturnError).target(TaskType.PSEUDO_InspectionObligationDepositReturn)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterInspectionDepositReturnError, TaskType.PSEUDO_waitAfterInspectionDepositReturnRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.InspectionObligationDepositReturn)
.action(chain(activeWsAction, discardInspOblStash, inspOblDepositReturnAction))
.event(SsnEvent.REPEAT);
}
}
private void sourceIO(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
@ -270,7 +273,7 @@ public class FinalSessionStateMachineConfig
.action(formingPaymentInstructionAssetsAction);
}
private void sourceIOError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourceIOPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after InspectionObligations
.withExternal()
@ -279,26 +282,30 @@ public class FinalSessionStateMachineConfig
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(formingPaymentInstructionReturnMkrAction)
.action(formingPaymentInstructionAssetsAction)
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterInspectionError).target(TaskType.InspectionObligations)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterInspectionError, TaskType.PSEUDO_waitAfterInspectionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.InspectionObligations)
.action(chain(activeWsAction, discardInspOblStash, inspectionObligationsV2Action))
.event(SsnEvent.REPEAT);
}
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool)
.action(chain(activeWsAction, obligationAdmissionContinueAction, inclusionToPoolAction))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
private void sourceFormingPaymentInstruction(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {

18
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/IntermediateMkrSessionStateMachineConfig.java
View file

@ -4,6 +4,7 @@ import java.time.LocalDate;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Configuration;
@ -155,7 +156,8 @@ public class IntermediateMkrSessionStateMachineConfig
TaskType.FinishingSession,
TaskType.PSEUDO_waitSdfAfterPaymentInstructions,
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.PSEUDO_waitSdfAfterAgainRevise
TaskType.PSEUDO_waitSdfAfterAgainRevise,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore
)))
.end(TaskType.FinishingSession);
}
@ -186,7 +188,7 @@ public class IntermediateMkrSessionStateMachineConfig
.action(inspectionObligationsV2Action);
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterOAPause(transitions);
sourceFormingPaymentInstructions(transitions);
sourcePseudoWaitSdfAfterPaymentInstructions(transitions);
sourceAgainRevise(transitions);
@ -216,18 +218,20 @@ public class IntermediateMkrSessionStateMachineConfig
.action(chain(obligationAdmissionContinueAction, inclusionToPoolAction));
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after ObligationAdmission
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool)
.action(chain(activeWsAction, obligationAdmissionContinueAction, inclusionToPoolAction))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
private void sourceFormingPaymentInstructions(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {

32
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PaymSessionStateMachineConfig.java
View file

@ -135,7 +135,9 @@ public class PaymSessionStateMachineConfig extends EnumStateMachineConfigurerAda
TaskType.FinishingSession,
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.AgainRevise,
TaskType.PSEUDO_waitAfterInspectionError
TaskType.PSEUDO_waitAfterInspectionError,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore,
TaskType.PSEUDO_waitAfterInspectionRestore
)))
.end(TaskType.FinishingSession);
}
@ -175,8 +177,8 @@ public class PaymSessionStateMachineConfig extends EnumStateMachineConfigurerAda
.guard(reviseSuccessGuard);
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterIOError(transitions);
sourcePseudoAfterOAPause(transitions);
sourcePseudoAfterIOPause(transitions);
sourceInspection(transitions);
}
@ -209,21 +211,23 @@ public class PaymSessionStateMachineConfig extends EnumStateMachineConfigurerAda
.action(formingPaymentInstructionAssetsAction);
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after ObligationAdmission
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool)
.action(chain(activeWsAction, obligationAdmissionContinueAction, inclusionToPoolAction))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
private void sourcePseudoAfterIOError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterIOPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after InspectionObligations
.withExternal()
@ -231,12 +235,14 @@ public class PaymSessionStateMachineConfig extends EnumStateMachineConfigurerAda
.action(activeWsAction)
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(formingPaymentInstructionAssetsAction)
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterInspectionError).target(TaskType.InspectionObligations)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterInspectionError, TaskType.PSEUDO_waitAfterInspectionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.InspectionObligations)
.action(chain(activeWsAction, discardInspOblStash, inspectionObligationsV2Action))
.event(SsnEvent.REPEAT);
}
}
@Override

17
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrepSessionStateMachineConfig.java
View file

@ -109,7 +109,8 @@ public class PrepSessionStateMachineConfig extends EnumStateMachineConfigurerAda
TaskType.RequirementsAndObligationsCreate,
TaskType.ObligationsAdmission,
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.PSEUDO_end
TaskType.PSEUDO_end,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore
)))
.end(TaskType.PSEUDO_end);
}
@ -130,7 +131,7 @@ public class PrepSessionStateMachineConfig extends EnumStateMachineConfigurerAda
.action(obligationAdmissionAction)
.and();
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterOAPause(transitions);
}
private void sourceObligationAdmission(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
@ -147,17 +148,19 @@ public class PrepSessionStateMachineConfig extends EnumStateMachineConfigurerAda
.action(chain(obligationAdmissionContinueAction, endSession));
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.PSEUDO_end)
.action(chain(activeWsAction, obligationAdmissionContinueAction, endSession))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
@Override

33
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionB0SessionStateMachineConfig.java
View file

@ -157,7 +157,9 @@ public class PrimaryAuctionB0SessionStateMachineConfig
TaskType.PSEUDO_waitSdfAfterPaymentInstructions,
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.PSEUDO_waitSdfAfterAgainRevise,
TaskType.PSEUDO_waitAfterInspectionError
TaskType.PSEUDO_waitAfterInspectionError,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore,
TaskType.PSEUDO_waitAfterInspectionRestore
)))
.end(TaskType.FinishingSession);
}
@ -187,8 +189,8 @@ public class PrimaryAuctionB0SessionStateMachineConfig
.source(TaskType.InclusionToPool).target(TaskType.InspectionObligations)
.action(inspectionObligationsV2Action);
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterIOError(transitions);
sourcePseudoAfterOAPause(transitions);
sourcePseudoAfterIOPause(transitions);
sourceFormingPaymentInstruction(transitions);
sourcePseudoWaitSdfAfterPaymentInstructions(transitions);
sourceAgainRevise(transitions);
@ -226,21 +228,23 @@ public class PrimaryAuctionB0SessionStateMachineConfig
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after ObligationAdmission
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool)
.action(chain(activeWsAction, obligationAdmissionContinueAction, inclusionToPoolAction))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
private void sourcePseudoAfterIOError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterIOPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after InspectionObligations
.withExternal()
@ -248,12 +252,15 @@ public class PrimaryAuctionB0SessionStateMachineConfig
.action(activeWsAction)
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(formingPaymentInstructionSecuritiesAction)
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterInspectionError).target(TaskType.InspectionObligations)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterInspectionError, TaskType.PSEUDO_waitAfterInspectionRestore)) {
transitions
.withExternal()
.source(taskType)
.target(TaskType.InspectionObligations)
.action(chain(activeWsAction, discardInspOblStash, inspectionObligationsV2Action))
.event(SsnEvent.REPEAT);
}
}
private void sourceFormingPaymentInstruction(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {

32
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionBnSessionStateMachineConfig.java
View file

@ -151,7 +151,9 @@ public class PrimaryAuctionBnSessionStateMachineConfig
TaskType.FinishingSession,
TaskType.PSEUDO_waitSdfAfterPaymentInstructions,
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.PSEUDO_waitAfterInspectionError
TaskType.PSEUDO_waitAfterInspectionError,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore,
TaskType.PSEUDO_waitAfterInspectionRestore
)))
.end(TaskType.FinishingSession);
}
@ -182,8 +184,8 @@ public class PrimaryAuctionBnSessionStateMachineConfig
.action(inspectionObligationsV2Action);
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterIOError(transitions);
sourcePseudoAfterOAPause(transitions);
sourcePseudoAfterIOPause(transitions);
sourceFormingPaymentInstruction(transitions);
sourcePseudoWaitSdfAfterPaymentInstructions(transitions);
sourceInspection(transitions);
@ -218,21 +220,23 @@ public class PrimaryAuctionBnSessionStateMachineConfig
.action(formingPaymentInstructionSecuritiesAction);
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after ObligationAdmission
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool)
.action(chain(activeWsAction, obligationAdmissionContinueAction, inclusionToPoolAction))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
private void sourcePseudoAfterIOError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterIOPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after InspectionObligations
.withExternal()
@ -240,12 +244,14 @@ public class PrimaryAuctionBnSessionStateMachineConfig
.action(activeWsAction)
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(formingPaymentInstructionSecuritiesAction)
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterInspectionError).target(TaskType.InspectionObligations)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterInspectionError, TaskType.PSEUDO_waitAfterInspectionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.InspectionObligations)
.action(chain(activeWsAction, discardInspOblStash, inspectionObligationsV2Action))
.event(SsnEvent.REPEAT);
}
}
private void sourceFormingPaymentInstruction(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {

32
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionT0SessionStateMachineConfig.java
View file

@ -158,7 +158,9 @@ public class PrimaryAuctionT0SessionStateMachineConfig
TaskType.PSEUDO_waitSdfAfterPaymentInstructions,
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.PSEUDO_waitSdfAfterAgainRevise,
TaskType.PSEUDO_waitAfterInspectionError
TaskType.PSEUDO_waitAfterInspectionError,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore,
TaskType.PSEUDO_waitAfterInspectionRestore
)))
.end(TaskType.FinishingSession);
}
@ -189,8 +191,8 @@ public class PrimaryAuctionT0SessionStateMachineConfig
.action(inspectionObligationsV2Action);
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterIOError(transitions);
sourcePseudoAfterOAPause(transitions);
sourcePseudoAfterIOPause(transitions);
sourceFormingPaymentInstruction(transitions);
sourcePseudoWaitSdfAfterPaymentInstructions(transitions);
sourceAgainRevise(transitions);
@ -227,21 +229,23 @@ public class PrimaryAuctionT0SessionStateMachineConfig
.action(formingPaymentInstructionSecuritiesAction);
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after ObligationAdmission
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool)
.action(chain(activeWsAction, obligationAdmissionContinueAction, inclusionToPoolAction))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
private void sourcePseudoAfterIOError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterIOPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after InspectionObligations
.withExternal()
@ -249,12 +253,14 @@ public class PrimaryAuctionT0SessionStateMachineConfig
.action(activeWsAction)
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(formingPaymentInstructionSecuritiesAction)
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterInspectionError).target(TaskType.InspectionObligations)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterInspectionError, TaskType.PSEUDO_waitAfterInspectionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.InspectionObligations)
.action(chain(activeWsAction, discardInspOblStash, inspectionObligationsV2Action))
.event(SsnEvent.REPEAT);
}
}
private void sourceFormingPaymentInstruction(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {

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

@ -169,7 +169,9 @@ public class UnitedSessionStateMachineConfig
TaskType.PSEUDO_waitAfterObligationAdmissionError,
TaskType.AgainRevise,
TaskType.PSEUDO_waitSdfAfterAgainRevise,
TaskType.PSEUDO_waitAfterInspectionError
TaskType.PSEUDO_waitAfterInspectionError,
TaskType.PSEUDO_waitAfterObligationAdmissionRestore,
TaskType.PSEUDO_waitAfterInspectionRestore
)))
.end(TaskType.FinishingSession);
}
@ -203,8 +205,8 @@ public class UnitedSessionStateMachineConfig
.source(TaskType.InclusionToPool).target(TaskType.InspectionObligations)
.action(inspectionObligationsV2Action);
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
sourcePseudoAfterIOError(transitions);
sourcePseudoAfterOAPause(transitions);
sourcePseudoAfterIOPause(transitions);
sourceFormingPaymentInstruction(transitions);
sourceAgainRevise(transitions);
sourcePseudoWaitAfterAgainRevise(transitions);
@ -258,21 +260,23 @@ public class UnitedSessionStateMachineConfig
.action(formingPaymentInstructionAssetsAction);
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterOAPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after ObligationAdmission
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool)
.action(chain(activeWsAction, obligationAdmissionContinueAction, inclusionToPoolAction))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterObligationAdmissionError, TaskType.PSEUDO_waitAfterObligationAdmissionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.ObligationsAdmission)
.action(chain(activeWsAction, discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
}
private void sourcePseudoAfterIOError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
private void sourcePseudoAfterIOPause(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
//continue and repeat after InspectionObligations
.withExternal()
@ -280,12 +284,14 @@ public class UnitedSessionStateMachineConfig
.action(activeWsAction)
.action(saveRegistriesAfterInspectionAndContinueAction)
.action(formingPaymentInstructionAssetsAction)
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterInspectionError).target(TaskType.InspectionObligations)
.event(SsnEvent.CONTINUE);
for (var taskType : List.of(TaskType.PSEUDO_waitAfterInspectionError, TaskType.PSEUDO_waitAfterInspectionRestore)) {
transitions
.withExternal()
.source(taskType).target(TaskType.InspectionObligations)
.action(chain(activeWsAction, discardInspOblStash, inspectionObligationsV2Action))
.event(SsnEvent.REPEAT);
}
}
private void sourceFormingPaymentInstruction(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {

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

@ -62,8 +62,9 @@ public enum TaskType implements IEnumKey {
PSEUDO_waitAfterObligationAdmissionRestore("PSEUDO_waitAfterObligationAdmissionRestore"),
PSEUDO_waitAfterInspectionError("PSEUDO_waitAfterInspectionError"),
PSEUDO_waitAfterInspectionRestore("PSEUDO_waitAfterInspectionRestore"),
PSEUDO_waitAfterInspectionDepositReturnRestore("PSEUDO_waitAfterInspectionDepositReturnRestore"),
PSEUDO_waitAfterInspectionDepositReturnError("PSEUDO_waitAfterInspectionDepositReturnError"),
PSEUDO_InspectionObligationDepositReturn("PSEUDO_InspectionObligationDepositReturn"),
InspectionObligationDepositReturn("C5_0"),
PSEUDO_end("PSEUDO_end"),
;

2
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/factory/RestoreSessionService.java
View file

@ -36,6 +36,7 @@ public class RestoreSessionService {
switch (status) {
case ObligationsAdmission -> restoredState = TaskType.PSEUDO_waitAfterObligationAdmissionRestore;
case InspectionObligations -> restoredState = TaskType.PSEUDO_waitAfterInspectionRestore;
case InspectionObligationDepositReturn -> restoredState = TaskType.PSEUDO_waitAfterInspectionDepositReturnRestore;
default -> throw new IllegalStateException(
"Unexpected value: session.id=%d status %s".formatted(session.getId(), status)
);
@ -57,6 +58,7 @@ public class RestoreSessionService {
TaskType status = IEnumKey.getEnumByKey(TaskType.class, session.getSessionStatus());
boolean statusOk = IEnumKey.contains(status,
TaskType.ObligationsAdmission,
TaskType.InspectionObligationDepositReturn,
TaskType.InspectionObligations);
if (!statusOk) {
throw new IllegalStateException(