PrepSession state machine config

This commit is contained in:
ialbert 2025-07-03 19:30:09 +03:00
parent 1ab524aacd
commit 767347dbed
2 changed files with 160 additions and 0 deletions

View file

@ -0,0 +1,159 @@
package ru.spcex.clearing.config.state_machine_2.specific;
import java.time.Instant;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.function.Supplier;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Configuration;
import org.springframework.statemachine.action.Action;
import org.springframework.statemachine.config.EnableStateMachineFactory;
import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.listener.StateMachineListenerAdapter;
import ru.clearing.classes.statics.data.execution.ExecutionCurrency;
import ru.clearing.classes.statics.data.misc.Session;
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.ObligationAdmissionAction;
import ru.spcex.clearing.session.state.action.RequirementAndObligationCreationAction;
import ru.spcex.clearing.session.state.action.SaveRegistriesAndContinueAction;
import ru.spcex.clearing.session.state.guard.StashedRegistriesPresentGuard;
import ru.spcex.clearing.session.state.listener.MachineMonitoringListener;
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.Section;
import ru.spcex.platform.enumeration.SessionStatus;
import ru.spcex.platform.enumeration.SessionType;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
@Configuration("prepSessionStateMachineConfig")
@EnableStateMachineFactory(name = "PREP")
public class PrepSessionStateMachineConfig extends EnumStateMachineConfigurerAdapter<TaskType, SsnEvent> {
private final Imdg<Session> sessionImdg;
private final DealsPrepareAction dealsPrepareAction;
private final RequirementAndObligationCreationAction reqAndOblAction;
private final ObligationAdmissionAction obligationAdmissionAction;
private final SaveRegistriesAndContinueAction obligationAdmissionContinueAction;
private final Action<TaskType, SsnEvent> endSession;
private final DiscardRegistriesAction discardOblAdmStash =
new DiscardRegistriesAction(DataEnum.obligationAdmissionStashedRgs);
private final StashedRegistriesPresentGuard oblAdmGuard = new StashedRegistriesPresentGuard(
DataEnum.obligationAdmissionStashedRgs
);
private final SessionType SESSION_TYPE = SessionType.PREP;
public PrepSessionStateMachineConfig(ImdgProvider imdgProvider,
DealsPrepareAction dealsPrepare,
@Qualifier("requirementAndObligationCreationAction")
RequirementAndObligationCreationAction reqAndOblAction,
ObligationAdmissionAction obligationsAdmission,
@Qualifier("marketCodesForCurr")
Supplier<List<String>> marketCodes,
SaveRegistriesAndContinueAction obligationAdmissionContinueAction) {
this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
Imdg<ExecutionCurrency> executionCurrencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ExecutionCurrency, ExecutionCurrency.class);
this.dealsPrepareAction = dealsPrepare;
this.reqAndOblAction = reqAndOblAction;
this.obligationAdmissionAction = obligationsAdmission;
this.obligationAdmissionContinueAction = obligationAdmissionContinueAction;
this.endSession = ctx -> {
Session ssn = (Session) ctx.getExtendedState().getVariables().get(DataEnum.session);
if (ssn != null) {
ssn.setSessionStatus(SessionStatus.CLOS.getKey());
ssn.setWorkflowStatus(WorkflowStatus.Blocked.getKey());
ssn.setUpdated(Instant.now());
sessionImdg.update(ssn);
}
};
ImdgPredicateBuilder execFondPb = executionCurrencyImdg.predicateBuilder();
dealsPrepareAction.searchForExecutions(ExecutionType.ExecutionCurrency);
dealsPrepareAction.addExecutionCurrencyCondition(execFondPb.regex("settlementCode", "^T0.*$"));
dealsPrepareAction.addExecutionCurrencyCondition(execFondPb.in("market", marketCodes.get().toArray(new String[0])));
this.obligationAdmissionContinueAction.setDataEnum(DataEnum.obligationAdmissionStashedRgs);
}
@Override
public void configure(StateMachineStateConfigurer<TaskType, SsnEvent> states) throws Exception {
states
.withStates()
.initial(TaskType.StartRevise, new CreateSessionAction(sessionImdg, SESSION_TYPE, Section.CURR))
.states(new HashSet<>(Arrays.asList(
TaskType.StartRevise,
TaskType.DealsPrepare,
TaskType.RequirementsAndObligationsCreate,
TaskType.ObligationsAdmission,
TaskType.PSEUDO_waitAfterObligationAdmissionError
)))
.end(TaskType.PSEUDO_end);
}
@Override
public void configure(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
.withExternal()
.source(TaskType.StartRevise).target(TaskType.DealsPrepare)
.action(dealsPrepareAction)
.and()
.withExternal()
.source(TaskType.DealsPrepare).target(TaskType.RequirementsAndObligationsCreate)
.action(reqAndOblAction)
.and()
.withExternal()
.source(TaskType.RequirementsAndObligationsCreate).target(TaskType.ObligationsAdmission)
.action(obligationAdmissionAction)
.and();
sourceObligationAdmission(transitions);
sourcePseudoAfterOAError(transitions);
}
private void sourceObligationAdmission(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
.withExternal()
.source(TaskType.ObligationsAdmission)
.target(TaskType.PSEUDO_waitAfterObligationAdmissionError)
.guard(oblAdmGuard)
.and()
.withExternal()
.source(TaskType.ObligationsAdmission).target(TaskType.PSEUDO_end)
.guard(invert(oblAdmGuard))
.action(chain(obligationAdmissionContinueAction, endSession));
}
private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer<TaskType, SsnEvent> transitions) throws Exception {
transitions
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.PSEUDO_end)
.action(chain(obligationAdmissionContinueAction, endSession))
.event(SsnEvent.CONTINUE)
.and()
.withExternal()
.source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission)
.action(chain(discardOblAdmStash, obligationAdmissionAction))
.event(SsnEvent.REPEAT);
}
@Override
public void configure(StateMachineConfigurationConfigurer<TaskType, SsnEvent> config) throws Exception {
StateMachineListenerAdapter<TaskType, SsnEvent> loggingChangeStateListener
= new MachineMonitoringListener(SESSION_TYPE.getKey());
config
.withConfiguration()
.machineId(SESSION_TYPE.getKey())
.listener(loggingChangeStateListener);
}
}

View file

@ -59,6 +59,7 @@ public enum TaskType implements IEnumKey {
PSEUDO_waitSdfAfterPaymentInstructions("PSEUDO_waitSdfAfterPaymentInstructions"),
PSEUDO_waitSdfAfterAgainRevise("PSEUDO_waitSdfAfterAgainRevise"),
PSEUDO_waitAfterObligationAdmissionError("PSEUDO_waitAfterObligationAdmissionError"),
PSEUDO_end("PSEUDO_end"),
;
private String key;