diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionBnSessionStateMachineConfig.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionBnSessionStateMachineConfig.java new file mode 100644 index 000000000..41ed6b82f --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionBnSessionStateMachineConfig.java @@ -0,0 +1,249 @@ +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; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.context.annotation.Configuration; +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.guard.Guard; +import org.springframework.statemachine.listener.StateMachineListenerAdapter; +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.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.FormingPaymentInstructionSecuritiesAction; +import ru.spcex.clearing.session.state.action.InclusionToPoolAction; +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.ReviseStage1Action; +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 static ru.spcex.clearing.util.StateMachineUtil.*; +import ru.spcex.platform.classes.base.interfaces.ExecutionType; +import ru.spcex.platform.enumeration.Section; +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; + +@Configuration("intermediateMkrSessionStateMachineFactoryConfig") +@EnableStateMachineFactory(name = "IPOB") +public class PrimaryAuctionBnSessionStateMachineConfig + extends EnumStateMachineConfigurerAdapter { + + private final Imdg sessionImdg; + private final Sdf56Action sendSdf56Action; + private final ReviseStage1Action reviseStage1Action; + private final DealsPrepareAction dealsPrepareAction; + private final RequirementAndObligationCreationAction reqAndOblAction; + private final ObligationAdmissionAction obligationAdmissionAction; + private final InclusionToPoolAction inclusionToPoolAction; + private final InspectionObligationsV2Action inspectionObligationsV2Action; + private final FormingPaymentInstructionSecuritiesAction formingPaymentInstructionSecuritiesAction; + 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 Guard reviseSuccessGuard = guardCheckCtxForFlag(DataEnum.againReviseSuccess); + + private final SessionType SESSION_TYPE = SessionType.IPOB; + + + @Autowired + public PrimaryAuctionBnSessionStateMachineConfig( + ImdgProvider imdgProvider, + Sdf56Action sendSdf56Action, + ReviseStage1Action reviseStage1Action, + DealsPrepareAction dealsPrepareAction, + @Qualifier("requirementAndObligationCreationAction") + RequirementAndObligationCreationAction reqAndOblAction, + ObligationAdmissionAction obligationAdmissionAction, + InclusionToPoolAction inclusionToPoolAction, + InspectionObligationsV2Action inspectionObligationsV2Action, + FormingPaymentInstructionSecuritiesAction formingPaymentInstructionSecuritiesAction, + FinishingSessionAction finishingSessionAction, EndStageNotificationAction endStageNotificationAction, SaveRegistriesAndContinueAction obligationAdmissionContinueAction, @Qualifier("marketCodesForBn") Supplier> marketCodes + ) { + this.sendSdf56Action = sendSdf56Action; + this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); + Imdg executionFondImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ExecutionFond, ExecutionFond.class); + this.obligationAdmissionContinueAction = obligationAdmissionContinueAction; + this.reviseStage1Action = reviseStage1Action; + this.dealsPrepareAction = dealsPrepareAction; + this.reqAndOblAction = reqAndOblAction; + this.obligationAdmissionAction = obligationAdmissionAction; + this.inclusionToPoolAction = inclusionToPoolAction; + this.inspectionObligationsV2Action = inspectionObligationsV2Action; + this.formingPaymentInstructionSecuritiesAction = formingPaymentInstructionSecuritiesAction; + this.finishingSessionAction = finishingSessionAction; + this.endStageNotificationAction = endStageNotificationAction; + this.finishingSessionAction.setPr("0"); + + //stages settings: + this.dealsPrepareAction.searchForExecutions(ExecutionType.ExecutionFond); + ImdgPredicateBuilder execFondPb = executionFondImdg.predicateBuilder(); + dealsPrepareAction.addExecutionFondCondition(execFondPb.regex("settlementCode", "^B\\d{2}$")); + dealsPrepareAction.addExecutionFondCondition(execFondPb.in("market", marketCodes.get().toArray(new String[0]))); + this.obligationAdmissionContinueAction.setDataEnum(DataEnum.obligationAdmissionStashedRgs); + } + + @Override + public void configure(StateMachineStateConfigurer states) throws Exception { + states + .withStates() + .initial(TaskType.StartRevise, chain( + new CreateSessionAction(sessionImdg, SESSION_TYPE, Section.FOND), + sendSdf56Action)) + .states(new HashSet<>(Arrays.asList( + TaskType.StartRevise, + TaskType.StartRevisePart1, + TaskType.DealsPrepare, + TaskType.RequirementsAndObligationsCreate, + TaskType.ObligationsAdmission, + TaskType.InclusionToPool, + TaskType.InspectionObligations, + TaskType.FormingRegistersOnOS, + TaskType.FormingPaymentInstruction, + TaskType.FinishingSession, + TaskType.EndStageNotification, + TaskType.PSEUDO_waitSdfAfterPaymentInstructions, + TaskType.PSEUDO_waitAfterObligationAdmissionError + ))) + .end(TaskType.EndStageNotification); + } + + + @Override + public void configure(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .event(SsnEvent.SDF_57) + .source(TaskType.StartRevise).target(TaskType.StartRevisePart1) + .action(reviseStage1Action) + .and() + .withExternal() + .source(TaskType.StartRevisePart1).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() + .withExternal() + .source(TaskType.InclusionToPool).target(TaskType.InspectionObligations) + .action(inspectionObligationsV2Action) + .and() + .withExternal() + .source(TaskType.InspectionObligations).target(TaskType.FormingPaymentInstruction) + .action(formingPaymentInstructionSecuritiesAction) + .and() + .withExternal() + .source(TaskType.FinishingSession) + .target(TaskType.EndStageNotification) + .action(endStageNotificationAction); + sourceObligationAdmission(transitions); + sourcePseudoAfterOAError(transitions); + sourceFormingPaymentInstruction(transitions); + sourcePseudoWaitSdfAfterPaymentInstructions(transitions); + } + + private void sourceObligationAdmission(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .source(TaskType.ObligationsAdmission) + .target(TaskType.PSEUDO_waitAfterObligationAdmissionError) + .guard(oblAdmGuard) + .and() + .withExternal() + .source(TaskType.ObligationsAdmission).target(TaskType.InclusionToPool) + .guard(invert(oblAdmGuard)) + .action(chain(obligationAdmissionContinueAction, inclusionToPoolAction)); + } + + private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool) + .action(chain(obligationAdmissionContinueAction, inclusionToPoolAction)) + .event(SsnEvent.CONTINUE) + .and() + .withExternal() + .source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission) + .action(chain(discardOblAdmStash, obligationAdmissionAction)) + .event(SsnEvent.REPEAT); + } + + private void sourceFormingPaymentInstruction(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + //если не создалось paymentInstruction'ов + .withExternal() + .source(TaskType.FormingPaymentInstruction) + .target(TaskType.FinishingSession) + .guard(PaymentsWereNotCreatedGuard.instance) + .action(finishingSessionAction) + .and() + //если создались paymentInstruction, переходим в режим ожидания + .withExternal() + .source(TaskType.FormingPaymentInstruction) + .target(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) + .guard(PaymentsWereCreatedGuard.instance); + } + + private void sourcePseudoWaitSdfAfterPaymentInstructions(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) + .target(TaskType.FinishingSession) + .guard(new SdfGuard(SdfGuardExtractorAfterAssets.instance)) + .action(finishingSessionAction); + for (var event: EnumSet.of(SsnEvent.SDF_01, SsnEvent.SDF_57, SsnEvent.SDF_04)) { + transitions + .withInternal() + .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) + .event(event) + .action(SdfReceivedAction.instance); + } + } + + + @Override + public void configure(StateMachineConfigurationConfigurer config) throws Exception { + StateMachineListenerAdapter loggingChangeStateListener + = new MachineMonitoringListener(SESSION_TYPE.getKey()); + config + .withConfiguration() + .machineId(SESSION_TYPE.getKey()) + .listener(loggingChangeStateListener); + } +} diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionT0SessionStateMachineConfig.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionT0SessionStateMachineConfig.java index 919c12352..bb5d35ac6 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionT0SessionStateMachineConfig.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/PrimaryAuctionT0SessionStateMachineConfig.java @@ -114,7 +114,6 @@ public class PrimaryAuctionT0SessionStateMachineConfig //stages settings: this.dealsPrepareAction.searchForExecutions(ExecutionType.ExecutionFond); ImdgPredicateBuilder execFondPb = executionFondImdg.predicateBuilder(); - //execFondPb.regex("settlementCode", "^T0.*$") dealsPrepareAction.addExecutionFondCondition(execFondPb.regex("settlementCode", "^T0.*$")); dealsPrepareAction.addExecutionFondCondition(execFondPb.in("market", marketCodes.get().toArray(new String[0]))); this.obligationAdmissionContinueAction.setDataEnum(DataEnum.obligationAdmissionStashedRgs); diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/SecondaryAuctionT0SessionStateMachineConfig.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/SecondaryAuctionT0SessionStateMachineConfig.java new file mode 100644 index 000000000..8ca65943c --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/SecondaryAuctionT0SessionStateMachineConfig.java @@ -0,0 +1,276 @@ +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; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.context.annotation.Configuration; +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.guard.Guard; +import org.springframework.statemachine.listener.StateMachineListenerAdapter; +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.session.stage.TaskType; +import ru.spcex.clearing.session.state.DataEnum; +import ru.spcex.clearing.session.state.SsnEvent; +import ru.spcex.clearing.session.state.action.AgainReviseStage3Action; +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; +import ru.spcex.clearing.session.state.action.InclusionToPoolAction; +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.ReviseStage1Action; +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.SdfGuardExtractorAfterAgainRevise; +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 static ru.spcex.clearing.util.StateMachineUtil.*; +import ru.spcex.platform.classes.base.interfaces.ExecutionType; +import ru.spcex.platform.enumeration.Section; +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; + +@Configuration("intermediateMkrSessionStateMachineFactoryConfig") +@EnableStateMachineFactory(name = "IPOT") +public class SecondaryAuctionT0SessionStateMachineConfig + extends EnumStateMachineConfigurerAdapter { + + private final Imdg sessionImdg; + private final Sdf56Action sendSdf56Action; + private final ReviseStage1Action reviseStage1Action; + private final DealsPrepareAction dealsPrepareAction; + private final RequirementAndObligationCreationAction reqAndOblAction; + private final ObligationAdmissionAction obligationAdmissionAction; + private final InclusionToPoolAction inclusionToPoolAction; + private final InspectionObligationsV2Action inspectionObligationsV2Action; + private final FormingPaymentInstructionAssetsAction formingPaymentInstructionAssetsAction; + private final AgainReviseStage3Action againRevise; + 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 Guard reviseSuccessGuard = guardCheckCtxForFlag(DataEnum.againReviseSuccess); + + private final SessionType SESSION_TYPE = SessionType.TRDT; + + + @Autowired + public SecondaryAuctionT0SessionStateMachineConfig( + ImdgProvider imdgProvider, + Sdf56Action sendSdf56Action, + ReviseStage1Action reviseStage1Action, + DealsPrepareAction dealsPrepareAction, + @Qualifier("requirementAndObligationCreationAction") + RequirementAndObligationCreationAction reqAndOblAction, + ObligationAdmissionAction obligationAdmissionAction, + InclusionToPoolAction inclusionToPoolAction, + InspectionObligationsV2Action inspectionObligationsV2Action, + FormingPaymentInstructionAssetsAction formingPaymentInstructionAssetsAction, + AgainReviseStage3Action againRevise, + FinishingSessionAction finishingSessionAction, EndStageNotificationAction endStageNotificationAction, SaveRegistriesAndContinueAction obligationAdmissionContinueAction, @Qualifier("marketCodesForT0Primary") Supplier> marketCodes + ) { + this.sendSdf56Action = sendSdf56Action; + this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); + Imdg executionFondImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ExecutionFond, ExecutionFond.class); + this.againRevise = againRevise; + this.obligationAdmissionContinueAction = obligationAdmissionContinueAction; + this.reviseStage1Action = reviseStage1Action; + this.dealsPrepareAction = dealsPrepareAction; + this.reqAndOblAction = reqAndOblAction; + this.obligationAdmissionAction = obligationAdmissionAction; + this.inclusionToPoolAction = inclusionToPoolAction; + this.inspectionObligationsV2Action = inspectionObligationsV2Action; + this.formingPaymentInstructionAssetsAction = formingPaymentInstructionAssetsAction; + this.finishingSessionAction = finishingSessionAction; + this.endStageNotificationAction = endStageNotificationAction; + this.finishingSessionAction.setPr("1"); + + //stages settings: + this.dealsPrepareAction.searchForExecutions(ExecutionType.ExecutionFond); + ImdgPredicateBuilder execFondPb = executionFondImdg.predicateBuilder(); + dealsPrepareAction.addExecutionFondCondition(execFondPb.regex("settlementCode", "^T0.*$")); + dealsPrepareAction.addExecutionFondCondition(execFondPb.in("market", marketCodes.get().toArray(new String[0]))); + this.obligationAdmissionContinueAction.setDataEnum(DataEnum.obligationAdmissionStashedRgs); + } + + @Override + public void configure(StateMachineStateConfigurer states) throws Exception { + states + .withStates() + .initial(TaskType.StartRevise, chain( + new CreateSessionAction(sessionImdg, SESSION_TYPE, Section.FOND), + sendSdf56Action)) + .states(new HashSet<>(Arrays.asList( + TaskType.StartRevise, + TaskType.StartRevisePart1, + TaskType.DealsPrepare, + TaskType.RequirementsAndObligationsCreate, + TaskType.ObligationsAdmission, + TaskType.InclusionToPool, + TaskType.InspectionObligations, + TaskType.FormingRegistersOnOS, + TaskType.FormingPaymentInstruction, + TaskType.AgainRevise, + TaskType.FinishingSession, + TaskType.EndStageNotification, + TaskType.PSEUDO_waitSdfAfterPaymentInstructions, + TaskType.PSEUDO_waitAfterObligationAdmissionError + ))) + .end(TaskType.EndStageNotification); + } + + + @Override + public void configure(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .event(SsnEvent.SDF_57) + .source(TaskType.StartRevise).target(TaskType.StartRevisePart1) + .action(reviseStage1Action) + .and() + .withExternal() + .source(TaskType.StartRevisePart1).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() + .withExternal() + .source(TaskType.InclusionToPool).target(TaskType.InspectionObligations) + .action(inspectionObligationsV2Action) + .and() + .withExternal() + .source(TaskType.InspectionObligations).target(TaskType.FormingPaymentInstruction) + .action(formingPaymentInstructionAssetsAction) + .and() + .withExternal() + .source(TaskType.PSEUDO_waitSdfAfterAgainRevise) + .target(TaskType.AgainRevise) + .guard(new SdfGuard(SdfGuardExtractorAfterAgainRevise.instance)) + .action(againRevise) + .and() + .withExternal() + .source(TaskType.FinishingSession) + .target(TaskType.EndStageNotification) + .action(endStageNotificationAction); + sourceObligationAdmission(transitions); + sourcePseudoAfterOAError(transitions); + sourceFormingPaymentInstruction(transitions); + sourcePseudoWaitSdfAfterPaymentInstructions(transitions); + sourceAgainRevise(transitions); + } + + private void sourceObligationAdmission(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .source(TaskType.ObligationsAdmission) + .target(TaskType.PSEUDO_waitAfterObligationAdmissionError) + .guard(oblAdmGuard) + .and() + .withExternal() + .source(TaskType.ObligationsAdmission).target(TaskType.InclusionToPool) + .guard(invert(oblAdmGuard)) + .action(chain(obligationAdmissionContinueAction, inclusionToPoolAction)); + } + + private void sourcePseudoAfterOAError(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.InclusionToPool) + .action(chain(obligationAdmissionContinueAction, inclusionToPoolAction)) + .event(SsnEvent.CONTINUE) + .and() + .withExternal() + .source(TaskType.PSEUDO_waitAfterObligationAdmissionError).target(TaskType.ObligationsAdmission) + .action(chain(discardOblAdmStash, obligationAdmissionAction)) + .event(SsnEvent.REPEAT); + } + + private void sourceFormingPaymentInstruction(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + //если не создалось paymentInstruction'ов + .withExternal() + .source(TaskType.FormingPaymentInstruction) + .target(TaskType.AgainRevise) + .guard(PaymentsWereNotCreatedGuard.instance) + .action(againRevise) + .and() + //если создались paymentInstruction, переходим в режим ожидания + .withExternal() + .source(TaskType.FormingPaymentInstruction) + .target(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) + .guard(PaymentsWereCreatedGuard.instance); + } + + private void sourcePseudoWaitSdfAfterPaymentInstructions(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) + .target(TaskType.AgainRevise) + .guard(new SdfGuard(SdfGuardExtractorAfterAssets.instance)) + .action(againRevise); + for (var event: EnumSet.of(SsnEvent.SDF_01, SsnEvent.SDF_57, SsnEvent.SDF_04)) { + transitions + .withInternal() + .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) + .event(event) + .action(SdfReceivedAction.instance); + } + } + + private void sourceAgainRevise(StateMachineTransitionConfigurer transitions) throws Exception { + transitions + .withExternal() + .source(TaskType.AgainRevise) + .target(TaskType.FinishingSession) + .action(finishingSessionAction) + .guard(reviseSuccessGuard) + .and() + .withExternal() + .source(TaskType.AgainRevise) + .target(TaskType.PSEUDO_waitSdfAfterAgainRevise) + .guard(invert(reviseSuccessGuard)); + } + + + @Override + public void configure(StateMachineConfigurationConfigurer config) throws Exception { + StateMachineListenerAdapter loggingChangeStateListener + = new MachineMonitoringListener(SESSION_TYPE.getKey()); + config + .withConfiguration() + .machineId(SESSION_TYPE.getKey()) + .listener(loggingChangeStateListener); + } +}