示例#1
0
        public void Throws_Exception_On_Unregistered_Event()
        {
            // Arrange

            var register = TransitionRegisterFactory.StartRegistrationFor <TransactionExecutionAggregate, TransactionExecutionState>();

            register.GetCurrentStateWith(a => a.State);

            register.From(TransactionExecutionState.Started)
            .On <SourceAddressLockedEvent>()
            .HandleTransition((a, e) => a.OnSourceAddressLocked());

            var core = register.Build();

            var aggregate = TransactionExecutionAggregate.Start
                            (
                Guid.NewGuid(),
                Guid.NewGuid(),
                0,
                "",
                new[] { new TransactionOutputValueType("", 0) },
                "",
                "",
                "",
                false
                            );

            // Act / Assert

            Assert.Throws <UnexpectedEventException>(() =>
            {
                core.Switch(aggregate, new TransactionBuiltEvent());
            });
        }
示例#2
0
        public void Throws_Exception_On_Transition_Configuration_Conflict()
        {
            var register = TransitionRegisterFactory.StartRegistrationFor <TransactionExecutionAggregate, TransactionExecutionState>();

            register.From(TransactionExecutionState.Started)
            .On <SourceAddressLockedEvent>()
            .HandleTransition((a, e) => a.OnSourceAddressLocked());

            Assert.Throws <ArgumentException>(() =>
            {
                register.In(TransactionExecutionState.Started)
                .Ignore <SourceAddressLockedEvent>();
            });
        }
示例#3
0
        public void Can_Ignore_Events()
        {
            // Arrange

            var register = TransitionRegisterFactory.StartRegistrationFor <TransactionExecutionAggregate, TransactionExecutionState>();

            register.GetCurrentStateWith(a => a.State);

            register.From(TransactionExecutionState.Started)
            .On <SourceAddressLockedEvent>()
            .HandleTransition((a, e) => a.OnSourceAddressLocked());

            register.In(TransactionExecutionState.Started)
            .Ignore <TransactionExecutionStartedEvent>();

            register.In(TransactionExecutionState.SourceAddressLocked)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>();

            var core = register.Build();

            var aggregate = TransactionExecutionAggregate.Start
                            (
                Guid.NewGuid(),
                Guid.NewGuid(),
                0,
                "",
                new[] { new TransactionOutputValueType("", 0) },
                "",
                "",
                "",
                false
                            );

            // Act

            var result1 = core.Switch(aggregate, new TransactionExecutionStartedEvent());
            var result2 = core.Switch(aggregate, new SourceAddressLockedEvent());
            var result3 = core.Switch(aggregate, new TransactionExecutionStartedEvent());
            var result4 = core.Switch(aggregate, new SourceAddressLockedEvent());

            // Assert

            Assert.False(result1);
            Assert.True(result2);
            Assert.False(result3);
            Assert.False(result4);
        }
示例#4
0
        public void Can_Proceed_Valid_Transaction_Multiple_Register()
        {
            // Arrange

            var register = TransitionRegisterFactory.StartRegistrationFor <TransactionExecutionAggregate, TransactionExecutionState>();

            register.GetCurrentStateWith(a => a.State);

            register.From(TransactionExecutionState.SourceAddressLocked, outputs =>
            {
                outputs.On <TransactionBuiltEvent>()
                .HandleTransition((a, e) => a.OnBuilt(e.FromAddressContext, e.TransactionContext));

                outputs.On <TransactionExecutionFailedEvent>()
                .HandleTransition((a, e) => a.OnBuildingFailed(e.ErrorCode, e.Error));
            });

            var core = register.Build();

            var aggregate1 = TransactionExecutionAggregate.Start
                             (
                Guid.NewGuid(),
                Guid.NewGuid(),
                0,
                "",
                new[] { new TransactionOutputValueType("", 0) },
                "",
                "",
                "",
                false
                             );

            aggregate1.OnSourceAddressLocked();

            var aggregate2 = TransactionExecutionAggregate.Start
                             (
                Guid.NewGuid(),
                Guid.NewGuid(),
                0,
                "",
                new[] { new TransactionOutputValueType("", 0) },
                "",
                "",
                "",
                false
                             );

            aggregate2.OnSourceAddressLocked();

            // Act

            var result1 = core.Switch(aggregate1, new TransactionBuiltEvent());
            var result2 = core.Switch(aggregate2, new TransactionExecutionFailedEvent
            {
                ErrorCode = TransactionExecutionResult.UnknownError
            });

            // Assert

            Assert.True(result1);
            Assert.Equal(TransactionExecutionState.Built, aggregate1.State);

            Assert.True(result2);
            Assert.Equal(TransactionExecutionState.BuildingFailed, aggregate2.State);
        }
示例#5
0
        public void Check_Transition_Preconditions()
        {
            // Arrange

            var register = TransitionRegisterFactory.StartRegistrationFor <TransactionExecutionAggregate, TransactionExecutionState>();

            register.GetCurrentStateWith(a => a.State);

            register.From(TransactionExecutionState.Started)
            .On <SourceAddressLockedEvent>()
            .WithPrecondition((a, e) => a.IncludeFee, (a, e) => "Include fee should be enabled")
            .WithPrecondition((a, e) => a.Outputs.Single().Amount > 0, (a, e) => "Amount should be positive number")
            .HandleTransition((a, e) => a.OnSourceAddressLocked());

            var core = register.Build();

            var aggregate1 = TransactionExecutionAggregate.Start
                             (
                Guid.NewGuid(),
                Guid.NewGuid(),
                0,
                "",
                new[] { new TransactionOutputValueType("", 0) },
                "",
                "",
                "",
                false
                             );

            var aggregate2 = TransactionExecutionAggregate.Start
                             (
                Guid.NewGuid(),
                Guid.NewGuid(),
                0,
                "",
                new[] { new TransactionOutputValueType("", 1) },
                "",
                "",
                "",
                true
                             );

            // Act

            Assert.Throws <UnexpectedEventException>(() =>
            {
                try
                {
                    core.Switch(aggregate1, new SourceAddressLockedEvent());
                }
                catch (Exception e)
                {
                    _output.WriteLine(e.ToString());
                    throw;
                }
            });

            var result21 = core.Switch(aggregate2, new SourceAddressLockedEvent());

            // Assert

            Assert.Equal(TransactionExecutionState.Started, aggregate1.State);

            Assert.True(result21);
            Assert.Equal(TransactionExecutionState.SourceAddressLocked, aggregate2.State);
        }
示例#6
0
        public void Can_Ignore_Already_Registered_Transition_With_Additional_Conditions()
        {
            // Arrange

            var register = TransitionRegisterFactory.StartRegistrationFor <TransactionExecutionAggregate, TransactionExecutionState>();

            register.GetCurrentStateWith(a => a.State);

            register.From(TransactionExecutionState.Started)
            .On <SourceAddressLockedEvent>()
            .HandleTransition((a, e) => a.OnSourceAddressLocked());

            register.In(TransactionExecutionState.Started)
            .Ignore <SourceAddressLockedEvent>((a, e) => a.IncludeFee)
            .Ignore <TransactionExecutionStartedEvent>();

            var core = register.Build();

            var aggregate1 = TransactionExecutionAggregate.Start
                             (
                Guid.NewGuid(),
                Guid.NewGuid(),
                0,
                "",
                new[] { new TransactionOutputValueType("", 0) },
                "",
                "",
                "",
                false
                             );

            var aggregate2 = TransactionExecutionAggregate.Start
                             (
                Guid.NewGuid(),
                Guid.NewGuid(),
                0,
                "",
                new[] { new TransactionOutputValueType("", 0) },
                "",
                "",
                "",
                true
                             );

            // Act

            var result11 = core.Switch(aggregate1, new TransactionExecutionStartedEvent());
            var result12 = core.Switch(aggregate1, new SourceAddressLockedEvent());

            var result21 = core.Switch(aggregate2, new TransactionExecutionStartedEvent());
            var result22 = core.Switch(aggregate2, new SourceAddressLockedEvent());

            // Assert

            Assert.False(result11);
            Assert.True(result12);
            Assert.Equal(TransactionExecutionState.SourceAddressLocked, aggregate1.State);

            Assert.False(result21);
            Assert.False(result22);
            Assert.Equal(TransactionExecutionState.Started, aggregate2.State);
        }
        public static IStateSwitcher <TransactionExecutionAggregate> Build()
        {
            var register = TransitionRegisterFactory.StartRegistrationFor <TransactionExecutionAggregate, TransactionExecutionState>();

            register.GetCurrentStateWith(aggregate => aggregate.State);

            register.From(TransactionExecutionState.Started)
            .On <SourceAddressLockedEvent>()
            .HandleTransition((a, e) => a.OnSourceAddressLocked());

            register.From(TransactionExecutionState.SourceAddressLocked, outputs =>
            {
                outputs.On <TransactionBuiltEvent>()
                .HandleTransition((a, e) => a.OnBuilt(e.FromAddressContext, e.TransactionContext));

                outputs.On <TransactionExecutionFailedEvent>()
                .HandleTransition((a, e) => a.OnBuildingFailed(e.ErrorCode, e.Error));
            });

            register.From(TransactionExecutionState.Built)
            .On <TransactionSignedEvent>()
            .HandleTransition((a, e) => a.OnSigned(e.SignedTransaction));

            register.From(TransactionExecutionState.Signed, outputs =>
            {
                outputs.On <TransactionBroadcastedEvent>()
                .HandleTransition((a, e) => a.OnBroadcasted());

                outputs.On <TransactionExecutionFailedEvent>()
                .HandleTransition((a, e) => a.OnBroadcastingFailed(e.ErrorCode, e.Error));

                outputs.On <TransactionExecutionRepeatRequestedEvent>()
                .HandleTransition((a, e) => a.OnBroadcastingFailed(e.ErrorCode, e.Error));
            });

            register.From(TransactionExecutionState.Broadcasted)
            .On <SourceAddressLockReleasedEvent>()
            .HandleTransition((a, e) => a.OnWaitingForEndingStarted());

            register.From(TransactionExecutionState.WaitingForEnding, outputs =>
            {
                outputs.On <TransactionExecutionCompletedEvent>()
                .HandleTransition((a, e) => a.OnCompleted(
                                      e.TransactionOutputs?
                                      .Select(o => o.ToDomain())
                                      .ToArray(),
                                      e.TransactionBlock,
                                      e.TransactionFee,
                                      e.TransactionHash));

                outputs.On <TransactionExecutionFailedEvent>()
                .HandleTransition((a, e) => a.OnWaitingForEndingFailed(e.ErrorCode, e.Error));

                outputs.On <TransactionExecutionRepeatRequestedEvent>()
                .HandleTransition((a, e) => a.OnWaitingForEndingFailed(e.ErrorCode, e.Error));
            });

            register.From(TransactionExecutionState.Completed)
            .On <BroadcastedTransactionClearedEvent>()
            .HandleTransition((a, e) => a.OnCleared());

            register.From(TransactionExecutionState.WaitingForEndingFailed)
            .On <BroadcastedTransactionClearedEvent>()
            .HandleTransition((a, e) => a.OnCleared());

            register.From(TransactionExecutionState.BuildingFailed)
            .On <SourceAddressLockReleasedEvent>()
            .HandleTransition((a, e) => a.OnSourceAddressLockReleased());

            register.From(TransactionExecutionState.BroadcastingFailed)
            .On <SourceAddressLockReleasedEvent>()
            .HandleTransition((a, e) => a.OnSourceAddressLockReleased());

            register.From(TransactionExecutionState.SourceAddressReleased)
            .On <BroadcastedTransactionClearedEvent>()
            .HandleTransition((a, e) => a.OnCleared());

            // Ignore events which already processed and possibly could be retried due to infrastructure failures

            register.In(TransactionExecutionState.Started)
            .Ignore <TransactionExecutionStartedEvent>();

            register.In(TransactionExecutionState.SourceAddressLocked)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>();

            register.In(TransactionExecutionState.Built)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>();

            register.In(TransactionExecutionState.BuildingFailed)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionExecutionFailedEvent>();

            register.In(TransactionExecutionState.Signed)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>()
            .Ignore <TransactionSignedEvent>();

            register.In(TransactionExecutionState.Broadcasted)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>()
            .Ignore <TransactionSignedEvent>()
            .Ignore <TransactionBroadcastedEvent>();

            register.In(TransactionExecutionState.BroadcastingFailed)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>()
            .Ignore <TransactionSignedEvent>()
            .Ignore <TransactionExecutionFailedEvent>()
            .Ignore <TransactionExecutionRepeatRequestedEvent>();

            register.In(TransactionExecutionState.WaitingForEnding)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>()
            .Ignore <TransactionSignedEvent>()
            .Ignore <TransactionBroadcastedEvent>()
            .Ignore <SourceAddressLockReleasedEvent>();

            register.In(TransactionExecutionState.SourceAddressReleased)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>()
            .Ignore <TransactionSignedEvent>()
            .Ignore <TransactionExecutionFailedEvent>()
            .Ignore <TransactionExecutionRepeatRequestedEvent>()
            .Ignore <SourceAddressLockReleasedEvent>();

            register.In(TransactionExecutionState.Completed)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>()
            .Ignore <TransactionSignedEvent>()
            .Ignore <TransactionBroadcastedEvent>()
            .Ignore <SourceAddressLockReleasedEvent>()
            .Ignore <TransactionExecutionCompletedEvent>();

            register.In(TransactionExecutionState.WaitingForEndingFailed)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>()
            .Ignore <TransactionSignedEvent>()
            .Ignore <TransactionBroadcastedEvent>()
            .Ignore <SourceAddressLockReleasedEvent>()
            .Ignore <TransactionExecutionFailedEvent>()
            .Ignore <TransactionExecutionRepeatRequestedEvent>();

            register.In(TransactionExecutionState.Cleared)
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <SourceAddressLockedEvent>()
            .Ignore <TransactionBuiltEvent>()
            .Ignore <TransactionSignedEvent>()
            .Ignore <TransactionBroadcastedEvent>()
            .Ignore <SourceAddressLockReleasedEvent>()
            .Ignore <TransactionExecutionCompletedEvent>()
            .Ignore <TransactionExecutionFailedEvent>()
            .Ignore <TransactionExecutionRepeatRequestedEvent>()
            .Ignore <BroadcastedTransactionClearedEvent>();

            return(register.Build());
        }
        public static IStateSwitcher <OperationExecutionAggregate> Build()
        {
            var register = TransitionRegisterFactory.StartRegistrationFor <OperationExecutionAggregate, OperationExecutionState>();

            register.GetCurrentStateWith(aggregate => aggregate.State);

            register.From(OperationExecutionState.Started)
            .On <ActiveTransactionIdGeneratedEvent>()
            .WithPrecondition((a, e) => e.TransactionNumber == 1, (a, e) => "Transaction number should be 1")
            .WithPrecondition((a, e) => a.ActiveTransactionNumber == 0, (a, e) => "Active transaction number should be 0")
            .WithPrecondition((a, e) => a.ActiveTransactionId == null, (a, e) => "Active transaction should be null")
            .HandleTransition((a, e) => a.OnActiveTransactionIdGenerated(e.TransactionId, e.TransactionNumber));

            register.From(OperationExecutionState.ActiveTransactionIdGenerated)
            .On <TransactionExecutionStartedEvent>()
            .WithPrecondition((a, e) => a.ActiveTransactionNumber == e.TransactionNumber, (a, e) => $"Unexpected transaction number. Active transaction number is [{a.ActiveTransactionNumber}]")
            .HandleTransition((a, e) => a.OnTransactionExecutionStarted());

            register.From(OperationExecutionState.TransactionExecutionInProgress, outputs =>
            {
                outputs.On <TransactionExecutionRepeatRequestedEvent>()
                .WithPrecondition((a, e) => a.ActiveTransactionNumber == e.TransactionNumber, (a, e) => $"Unexpected transaction number. Active transaction number is [{a.ActiveTransactionNumber}]")
                .HandleTransition((a, e) => a.OnTransactionExecutionRepeatRequested(
                                      e.Error));

                outputs.On <TransactionExecutionCompletedEvent>()
                .WithPrecondition((a, e) => a.ActiveTransactionNumber == e.TransactionNumber, (a, e) => $"Unexpected transaction number. Active transaction number is [{a.ActiveTransactionNumber}]")
                .HandleTransition((a, e) => a.OnTransactionExecutionCompleted(
                                      e.TransactionOutputs?
                                      .Select(o => o.ToDomain())
                                      .ToArray(),
                                      e.TransactionBlock,
                                      e.TransactionFee,
                                      e.TransactionHash));

                outputs.On <TransactionExecutionFailedEvent>()
                .WithPrecondition((a, e) => a.ActiveTransactionNumber == e.TransactionNumber, (a, e) => $"Unexpected transaction number. Active transaction number is [{a.ActiveTransactionNumber}]")
                .WithPrecondition((a, e) => e.ErrorCode != TransactionExecutionResult.Completed, (a, e) => $"Error code should be not {TransactionExecutionResult.Completed}")
                .HandleTransition((a, e) => a.OnTransactionExecutionFailed(
                                      e.ErrorCode.MapToOperationExecutionResult(),
                                      e.Error));
            });

            register.From(OperationExecutionState.TransactionExecutionRepeatRequested)
            .On <ActiveTransactionClearedEvent>()
            .WithPrecondition((a, e) => a.ActiveTransactionNumber == e.TransactionNumber, (a, e) => $"Unexpected transaction number. Active transaction number is [{a.ActiveTransactionNumber}]")
            .WithPrecondition((a, e) => a.ActiveTransactionId != null, (a, e) => "Active transaction should be not null")
            .HandleTransition((a, e) => a.OnActiveTransactionCleared());


            register.From(OperationExecutionState.ActiveTransactionCleared, outputs =>
            {
                outputs.On <ActiveTransactionIdGeneratedEvent>()
                .WithPrecondition((a, e) => e.TransactionNumber == a.ActiveTransactionNumber + 1, (a, e) => $"Transaction number should be active transaction number [{a.ActiveTransactionNumber}] + 1")
                .WithPrecondition((a, e) => a.ActiveTransactionId == null, (a, e) => "Active transaction should be null")
                .HandleTransition((a, e) => a.OnActiveTransactionIdGenerated(e.TransactionId, e.TransactionNumber));

                outputs.On <TransactionReBuildingRejectedEvent>()
                .WithPrecondition((a, e) => a.ActiveTransactionId == null, (a, e) => "Active transaction should be null")
                .HandleTransition((a, e) => a.OnTransactionExecutionFailed(OperationExecutionResult.RebuildingRejected, "Rebuilding rejected"));
            });


            register.From(OperationExecutionState.Completed)
            .On <OperationExecutionCompletedEvent>()
            .HandleTransition((a, e) => a.OnNotifiedAboutEnding());

            register.From(OperationExecutionState.Completed)
            .On <OneToManyOperationExecutionCompletedEvent>()
            .HandleTransition((a, e) => a.OnNotifiedAboutEnding());

            register.From(OperationExecutionState.Failed)
            .On <OperationExecutionFailedEvent>()
            .HandleTransition((a, e) => a.OnNotifiedAboutEnding());

            // Ignore events which already processed and possibly could be retried due to infrastructure failures

            register.In(OperationExecutionState.Started)
            .Ignore <OperationExecutionStartedEvent>();

            register.In(OperationExecutionState.ActiveTransactionIdGenerated)
            .Ignore <OperationExecutionStartedEvent>()
            .Ignore <ActiveTransactionIdGeneratedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <TransactionReBuildingRejectedEvent>()
            .Ignore <TransactionExecutionStartedEvent>((a, e) => a.ActiveTransactionNumber > e.TransactionNumber)
            .Ignore <TransactionExecutionRepeatRequestedEvent>((a, e) => a.ActiveTransactionNumber > e.TransactionNumber)
            .Ignore <ActiveTransactionClearedEvent>((a, e) => a.ActiveTransactionNumber > e.TransactionNumber);

            register.In(OperationExecutionState.TransactionExecutionInProgress)
            .Ignore <OperationExecutionStartedEvent>()
            .Ignore <ActiveTransactionIdGeneratedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <TransactionReBuildingRejectedEvent>()
            .Ignore <TransactionExecutionStartedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <TransactionExecutionRepeatRequestedEvent>((a, e) => a.ActiveTransactionNumber > e.TransactionNumber)
            .Ignore <ActiveTransactionClearedEvent>((a, e) => a.ActiveTransactionNumber > e.TransactionNumber);

            register.In(OperationExecutionState.TransactionExecutionRepeatRequested)
            .Ignore <OperationExecutionStartedEvent>()
            .Ignore <ActiveTransactionIdGeneratedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <TransactionReBuildingRejectedEvent>()
            .Ignore <TransactionExecutionStartedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <TransactionExecutionRepeatRequestedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <ActiveTransactionClearedEvent>((a, e) => a.ActiveTransactionNumber > e.TransactionNumber);

            register.In(OperationExecutionState.ActiveTransactionCleared)
            .Ignore <OperationExecutionStartedEvent>()
            .Ignore <ActiveTransactionIdGeneratedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <TransactionExecutionStartedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <TransactionExecutionRepeatRequestedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber)
            .Ignore <ActiveTransactionClearedEvent>((a, e) => a.ActiveTransactionNumber >= e.TransactionNumber);

            register.In(OperationExecutionState.Completed)
            .Ignore <OperationExecutionStartedEvent>()
            .Ignore <ActiveTransactionIdGeneratedEvent>()
            .Ignore <TransactionReBuildingRejectedEvent>()
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <TransactionExecutionRepeatRequestedEvent>()
            .Ignore <ActiveTransactionClearedEvent>()
            .Ignore <TransactionExecutionCompletedEvent>();

            register.In(OperationExecutionState.Failed)
            .Ignore <OperationExecutionStartedEvent>()
            .Ignore <ActiveTransactionIdGeneratedEvent>()
            .Ignore <TransactionReBuildingRejectedEvent>()
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <TransactionExecutionRepeatRequestedEvent>()
            .Ignore <ActiveTransactionClearedEvent>()
            .Ignore <TransactionExecutionFailedEvent>();

            register.In(OperationExecutionState.NotifiedAboutEnding)
            .Ignore <OperationExecutionStartedEvent>()
            .Ignore <ActiveTransactionIdGeneratedEvent>()
            .Ignore <TransactionReBuildingRejectedEvent>()
            .Ignore <TransactionExecutionStartedEvent>()
            .Ignore <TransactionExecutionRepeatRequestedEvent>()
            .Ignore <ActiveTransactionClearedEvent>()
            .Ignore <TransactionExecutionCompletedEvent>()
            .Ignore <TransactionExecutionFailedEvent>()
            .Ignore <OperationExecutionCompletedEvent>()
            .Ignore <OperationExecutionFailedEvent>()
            .Ignore <OneToManyOperationExecutionCompletedEvent>();

            return(register.Build());
        }