diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/CurrencySessionStateMachineConfig.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/CurrencySessionStateMachineConfig.java index fb2d8b06e..0b19f1901 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/CurrencySessionStateMachineConfig.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/config/state_machine_2/specific/CurrencySessionStateMachineConfig.java @@ -1,11 +1,10 @@ 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.slf4j.Logger; -import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.annotation.Configuration; import org.springframework.statemachine.config.EnableStateMachineFactory; @@ -35,11 +34,13 @@ import ru.spcex.clearing.session.state.action.RequirementAndObligationCreationAc 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.SdfGuardUtil; +import ru.spcex.clearing.session.state.guard.SdfSetGuard; import ru.spcex.clearing.session.state.guard.StashedRegistriesPresentGuard; import ru.spcex.clearing.session.state.listener.MachineMonitoringListener; import static ru.spcex.clearing.util.StateMachineUtil.*; @@ -53,7 +54,6 @@ import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; @Configuration("intermediateMkrSessionStateMachineFactoryConfig") @EnableStateMachineFactory(name = "CURR") public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigurerAdapter { - private final Logger log = LoggerFactory.getLogger(getClass()); private final Imdg sessionImdg; private final Sdf56Action sendSdf56Action; private final ReviseStage1Action reviseStage1Action; @@ -66,7 +66,6 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure private final AgainReviseStage3Action againRevise; private final FinishingSessionAction finishingSessionAction; private final EndStageNotificationAction endStageNotificationAction; - private final Imdg executionCurrencyImdg; private final SaveRegistriesAndContinueAction obligationAdmissionContinueAction; private final DiscardRegistriesAction discardOblAdmStash = new DiscardRegistriesAction(DataEnum.obligationAdmissionStashedRgs); @@ -74,7 +73,8 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure DataEnum.obligationAdmissionStashedRgs ); private final Guard reviseSuccessGuard = guardCheckCtxForFlag(DataEnum.againReviseSuccess); - private final SessionType SESSION_TYPE = SessionType.MEDM; + private final SessionType SESSION_TYPE = SessionType.CURR; + private final Section SECTION = Section.CURR; public CurrencySessionStateMachineConfig(ImdgProvider imdgProvider, Sdf56Action sendSdf56Action, @@ -93,7 +93,6 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure Supplier> marketCodes, SaveRegistriesAndContinueAction obligationAdmissionContinueAction) { this.sessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); - this.executionCurrencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ExecutionCurrency, ExecutionCurrency.class); this.sendSdf56Action = sendSdf56Action; this.reviseStage1Action = reviseStage1Action; this.dealsPrepareAction = dealsPrepare; @@ -108,6 +107,7 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure this.obligationAdmissionContinueAction = obligationAdmissionContinueAction; this.finishingSessionAction.setPr("1"); + Imdg executionCurrencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ExecutionCurrency, ExecutionCurrency.class); dealsPrepareAction.searchForExecutions(ExecutionType.ExecutionCurrency); ImdgPredicateBuilder execFondPb = executionCurrencyImdg.predicateBuilder(); dealsPrepareAction.addExecutionCurrencyCondition(execFondPb.regex("settlementCode", "^T0.*$")); @@ -120,7 +120,7 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure states .withStates() .initial(TaskType.StartRevise, chain( - new CreateSessionAction(sessionImdg, SessionType.MEDM, Section.MKR), + new CreateSessionAction(sessionImdg, SESSION_TYPE, SECTION), sendSdf56Action)) .states(new HashSet<>(Arrays.asList( TaskType.StartRevise, @@ -167,12 +167,6 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure .source(TaskType.InspectionObligations).target(TaskType.FormingPaymentInstruction) .action(formingPaymentInstructionAssetsAction) .and() - .withExternal() - .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) - .target(TaskType.AgainRevise) - .guard(new SdfGuard(SdfGuardExtractorAfterAssets.instance)) - .action(againRevise) - .and() .withExternal() .source(TaskType.PSEUDO_waitSdfAfterAgainRevise) .target(TaskType.AgainRevise) @@ -186,6 +180,7 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure sourceObligationAdmission(transitions); sourcePseudoAfterOAError(transitions); sourceFormingPaymentInstruction(transitions); + sourcePseudoWaitSdfAfterPaymentInstructions(transitions); sourceAgainRevise(transitions); } @@ -231,6 +226,23 @@ public class CurrencySessionStateMachineConfig extends EnumStateMachineConfigure .guard(PaymentsWereCreatedGuard.instance); } + private void sourcePseudoWaitSdfAfterPaymentInstructions(StateMachineTransitionConfigurer transitions) throws Exception { + EnumSet sdfs = SdfGuardUtil.bySectionAfter7Step(SECTION); + transitions + .withExternal() + .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) + .target(TaskType.AgainRevise) + .guard(new SdfSetGuard(sdfs)) + .action(againRevise); + for (var event : sdfs) { + transitions + .withInternal() + .source(TaskType.PSEUDO_waitSdfAfterPaymentInstructions) + .event(event) + .action(SdfReceivedAction.instance); + } + } + private void sourceAgainRevise(StateMachineTransitionConfigurer transitions) throws Exception { transitions .withExternal() diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/SsnEvent.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/SsnEvent.java index 2fc54f015..43e225126 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/SsnEvent.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/SsnEvent.java @@ -4,6 +4,9 @@ public enum SsnEvent { SDF_01, SDF_57, SDF_04, + SDF_13, + SDF_08, + SDF_21, PAUSE, CONTINUE, REPEAT diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/action/FormingPaymentInstructionSecuritiesAction.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/action/FormingPaymentInstructionSecuritiesAction.java index 98b55cf46..dc78390a1 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/action/FormingPaymentInstructionSecuritiesAction.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/action/FormingPaymentInstructionSecuritiesAction.java @@ -56,10 +56,10 @@ import static ru.spcex.platform.utils.number.BigDecimalUtil.safeBD; public class FormingPaymentInstructionSecuritiesAction extends AbstractSessionActionForOkErrorHandling { private final Logger log = LoggerFactory.getLogger(getClass()); - private ImdgProvider imdgProvider; - private Imdg registryImdg; - private Imdg paymentInstructionImdg; - private Imdg accountImdg; + private final ImdgProvider imdgProvider; + private final Imdg registryImdg; + private final Imdg paymentInstructionImdg; + private final Imdg accountImdg; private final RegistryManager rgsMng; private final Sdf03And12Sender sdf03And12Sender; diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfGuardExtractorAfterAssets.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfGuardExtractorAfterAssets.java index 5df0a12c4..450aa21a9 100644 --- a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfGuardExtractorAfterAssets.java +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfGuardExtractorAfterAssets.java @@ -1,6 +1,5 @@ package ru.spcex.clearing.session.state.guard; -import java.util.Collections; import java.util.EnumSet; import java.util.Set; import java.util.function.Function; @@ -8,7 +7,6 @@ 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.stage.impl.PaymentInfo; import ru.spcex.clearing.session.state.DataEnum; import ru.spcex.clearing.session.state.SsnEvent; import ru.spcex.platform.enumeration.SdfTable; @@ -26,11 +24,11 @@ public class SdfGuardExtractorAfterAssets implements Function { return EnumSet.of( diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfGuardUtil.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfGuardUtil.java new file mode 100644 index 000000000..52056132e --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfGuardUtil.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.session.state.guard; + +import java.util.EnumSet; +import ru.spcex.clearing.session.state.SsnEvent; +import ru.spcex.platform.enumeration.Section; + +public class SdfGuardUtil { + + public static EnumSet bySectionAfter7Step(Section section) { + switch (section) { + case MKR -> { + return EnumSet.of( + SsnEvent.SDF_04, + SsnEvent.SDF_01, + SsnEvent.SDF_57 + ); + } + case FOND, MULT -> { + return EnumSet.of( + SsnEvent.SDF_04, + SsnEvent.SDF_13, + SsnEvent.SDF_08, + SsnEvent.SDF_21, + SsnEvent.SDF_01, + SsnEvent.SDF_57 + ); + } + default -> throw new IllegalStateException("unknown wait conditions for section " + section); + } + } +} diff --git a/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfSetGuard.java b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfSetGuard.java new file mode 100644 index 000000000..2f1f71681 --- /dev/null +++ b/clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/state/guard/SdfSetGuard.java @@ -0,0 +1,48 @@ +package ru.spcex.clearing.session.state.guard; + +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.SsnEvent; + +public class SdfSetGuard implements Guard { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final EnumSet sdfs; + + public SdfSetGuard(SsnEvent first, SsnEvent... rest) { + this.sdfs = EnumSet.of(first, rest); + } + + public SdfSetGuard(EnumSet sdfs) { + this.sdfs = sdfs; + } + + @Override + public boolean evaluate(StateContext ctx) { + ExtendedState state = ctx.getExtendedState(); + Function was = sdf -> state.get(sdf.name(), Object.class) != null; + + 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())); + 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; + } + } +}