831 step deletion integration events refactor (#989)

richard1927 · web-flow · commit c2bb18254f3b · 2024-12-05T14:54:26.000+01:00
Instead of having the journey database repository drive event generation, we emit the events through the command handling.
diff --git a/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/EventHelpers/CreateJourneyDeletedEventHelper.cs b/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/EventHelpers/CreateJourneyDeletedEventHelper.cs
@@ -1,10 +1,16 @@
-﻿using System.Threading.Tasks;
+﻿using System.Linq;
 using Equinor.ProCoSys.Preservation.Command.Events;
 using Equinor.ProCoSys.Preservation.Domain.AggregateModels.JourneyAggregate;
 
 namespace Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents.EventHelpers;
 
-public class CreateJourneyDeletedEventHelper : ICreateEventHelper<Journey, JourneyDeleteEvent>
+public static class CreateJourneyDeletedEventHelper
 {
-    public Task<JourneyDeleteEvent> CreateEvent(Journey entity) => Task.FromResult(new JourneyDeleteEvent(entity.Guid, entity.Plant));
+    public static JourneyDeletedEvents CreateEvent(Journey entity)
+    {
+        var journeyDeletedEvent = new JourneyDeleteEvent(entity.Guid, entity.Plant);
+        var stepDeletedEvents = entity.Steps.Select(CreateStepDeletedEventHelper.CreateEvent).ToList();
+        
+        return new JourneyDeletedEvents(journeyDeletedEvent, stepDeletedEvents);
+    }
 }
diff --git a/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/EventHelpers/CreateStepDeleteEventHelper.cs b/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/EventHelpers/CreateStepDeleteEventHelper.cs
diff --git a/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/EventHelpers/CreateStepDeletedEventHelper.cs b/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/EventHelpers/CreateStepDeletedEventHelper.cs
@@ -0,0 +1,9 @@
+﻿using Equinor.ProCoSys.Preservation.Command.Events;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.JourneyAggregate;
+
+namespace Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents.EventHelpers;
+
+public static class CreateStepDeletedEventHelper
+{
+    public static StepDeleteEvent CreateEvent(Step entity) => new(entity.Guid, entity.Plant);
+}
diff --git a/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/EventHelpers/JourneyDeletedEvents.cs b/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/EventHelpers/JourneyDeletedEvents.cs
@@ -0,0 +1,9 @@
+﻿using System.Collections.Generic;
+using Equinor.ProCoSys.Preservation.Command.Events;
+
+namespace Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents.EventHelpers;
+
+public record JourneyDeletedEvents(
+    JourneyDeleteEvent JourneyDeleteEvent,
+    IEnumerable<StepDeleteEvent> StepDeleteEvents);
+
diff --git a/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/JourneyDeletedEventHandler.cs b/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/JourneyDeletedEventHandler.cs
@@ -0,0 +1,24 @@
+﻿using System.Threading;
+using System.Threading.Tasks;
+using Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents.EventHelpers;
+using Equinor.ProCoSys.Preservation.Command.EventPublishers;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.JourneyAggregate;
+using Equinor.ProCoSys.Preservation.Domain.Events;
+using MediatR;
+
+namespace Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents;
+
+public class JourneyDeletedEventHandler(IIntegrationEventPublisher integrationEventPublisher)
+    : INotificationHandler<DeletedEvent<Journey>>
+{
+    public async Task Handle(DeletedEvent<Journey> notification, CancellationToken cancellationToken)
+    {
+        var journeyDeleteEvents = CreateJourneyDeletedEventHelper.CreateEvent(notification.Entity);
+        await integrationEventPublisher.PublishAsync(journeyDeleteEvents.JourneyDeleteEvent, cancellationToken);
+
+        foreach (var stepDeleteEvent in journeyDeleteEvents.StepDeleteEvents)
+        {
+            await integrationEventPublisher.PublishAsync(stepDeleteEvent, cancellationToken);
+        }
+    }
+}
diff --git a/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/StepDeletedEventHandler.cs b/src/Equinor.ProCoSys.Preservation.Command/EventHandlers/IntegrationEvents/StepDeletedEventHandler.cs
@@ -0,0 +1,19 @@
+﻿using System.Threading;
+using System.Threading.Tasks;
+using Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents.EventHelpers;
+using Equinor.ProCoSys.Preservation.Command.EventPublishers;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.JourneyAggregate;
+using Equinor.ProCoSys.Preservation.Domain.Events;
+using MediatR;
+
+namespace Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents;
+
+public class StepDeletedEventHandler(IIntegrationEventPublisher integrationEventPublisher)
+    : INotificationHandler<DeletedEvent<Step>>
+{
+    public async Task Handle(DeletedEvent<Step> notification, CancellationToken cancellationToken)
+    {
+        var deleteEvent = CreateStepDeletedEventHelper.CreateEvent(notification.Entity);
+        await integrationEventPublisher.PublishAsync(deleteEvent, cancellationToken);
+    }
+}
diff --git a/src/Equinor.ProCoSys.Preservation.Command/JourneyCommands/DeleteJourney/DeleteJourneyCommandHandler.cs b/src/Equinor.ProCoSys.Preservation.Command/JourneyCommands/DeleteJourney/DeleteJourneyCommandHandler.cs
@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using Equinor.ProCoSys.Preservation.Domain;
 using Equinor.ProCoSys.Preservation.Domain.AggregateModels.JourneyAggregate;
+using Equinor.ProCoSys.Preservation.Domain.Events;
 using MediatR;
 using ServiceResult;
 
@@ -25,6 +26,8 @@ public async Task<Result<Unit>> Handle(DeleteJourneyCommand request, Cancellatio
             journey.SetRowVersion(request.RowVersion);
             _journeyRepository.Remove(journey);
             
+            journey.AddDomainEvent(new DeletedEvent<Journey>(journey));
+            
             await _unitOfWork.SaveChangesAsync(cancellationToken);
             return new SuccessResult<Unit>(Unit.Value);
         }
diff --git a/src/Equinor.ProCoSys.Preservation.Domain/AggregateModels/JourneyAggregate/Journey.cs b/src/Equinor.ProCoSys.Preservation.Domain/AggregateModels/JourneyAggregate/Journey.cs
@@ -82,7 +82,7 @@ public void RemoveStep(Step step)
             }
 
             _steps.Remove(step);
-            step.SetRemoved();
+            AddDomainEvent(new DeletedEvent<Step>(step));
         }
 
         public void SwapSteps(int stepId1, int stepId2)
@@ -202,7 +202,5 @@ public void SetModified(Person modifiedBy)
 
             AddDomainEvent(new ModifiedEvent<Journey>(this));
         }
-
-        public void SetRemoved() => AddDomainEvent(new DeletedEvent<Journey>(this));
     }
 }
diff --git a/src/Equinor.ProCoSys.Preservation.Domain/AggregateModels/JourneyAggregate/Step.cs b/src/Equinor.ProCoSys.Preservation.Domain/AggregateModels/JourneyAggregate/Step.cs
@@ -120,7 +120,5 @@ public void SetResponsible(Responsible responsible)
             
             AddDomainEvent(new ModifiedEvent<Step>(this));
         }
-
-        public void SetRemoved() => AddDomainEvent(new DeletedEvent<Step>(this));
     }
 }
diff --git a/src/Equinor.ProCoSys.Preservation.Infrastructure/Repositories/JourneyRepository.cs b/src/Equinor.ProCoSys.Preservation.Infrastructure/Repositories/JourneyRepository.cs
@@ -29,21 +29,15 @@ public Task<List<Journey>> GetJourneysWithAutoTransferStepsAsync(AutoTransferMet
                 .Where(journey => journey.Steps.Any(s => s.AutoTransferMethod == autoTransferMethod))
                 .ToListAsync();
 
-        public void RemoveStep(Step step)
-        {
-            _context.Steps.Remove(step);
-            step.SetRemoved();
-        }
+        public void RemoveStep(Step step) => _context.Steps.Remove(step);
 
         public override void Remove(Journey journey)
         {
             foreach (var step in journey.Steps)
             {
                 _context.Steps.Remove(step);
-                step.SetRemoved();
             }
             base.Remove(journey);
-            journey.SetRemoved();
         }
     }
 }
diff --git a/src/Equinor.ProCoSys.Preservation.WebApi/DiModules/ApplicationModule.cs b/src/Equinor.ProCoSys.Preservation.WebApi/DiModules/ApplicationModule.cs
@@ -153,11 +153,8 @@ public static void AddApplicationModules(this IServiceCollection services, IConf
             
             services.AddTransient<INotificationHandler<CreatedEvent<Journey>>, IntegrationEventHandler<CreatedEvent<Journey>, Journey>>();
             services.AddTransient<INotificationHandler<ModifiedEvent<Journey>>, IntegrationEventHandler<ModifiedEvent<Journey>, Journey>>();
-            services.AddTransient<INotificationHandler<DeletedEvent<Journey>>, IntegrationDeleteEventHandler<DeletedEvent<Journey>, Journey>>();
             services.AddTransient<IPublishEntityEventHelper<Journey>, PublishEntityEventHelper<Journey, JourneyEvent>>();
-            services.AddTransient<IPublishDeleteEntityEventHelper<Journey>, PublishDeleteEntityEventHelper<Journey, JourneyDeleteEvent>>();
             services.AddTransient<ICreateEventHelper<Journey, JourneyEvent>, CreateJourneyEventHelper>();
-            services.AddTransient<ICreateEventHelper<Journey, JourneyDeleteEvent>, CreateJourneyDeletedEventHelper>();
             
             services.AddTransient<INotificationHandler<CreatedEvent<Mode>>, IntegrationEventHandler<CreatedEvent<Mode>, Mode>>();
             services.AddTransient<INotificationHandler<ModifiedEvent<Mode>>, IntegrationEventHandler<ModifiedEvent<Mode>, Mode>>();
@@ -189,12 +186,9 @@ public static void AddApplicationModules(this IServiceCollection services, IConf
             services.AddTransient<INotificationHandler<ChildAddedEvent<Journey, Step>>, ChildEventHandler<Journey, Step, StepEvent>>();
             services.AddTransient<INotificationHandler<ChildModifiedEvent<Journey, Step>>, ChildEventHandler<Journey, Step, StepEvent>>();
             services.AddTransient<INotificationHandler<ModifiedEvent<Step>>, IntegrationEventHandler<ModifiedEvent<Step>, Step>>();
-            services.AddTransient<INotificationHandler<DeletedEvent<Step>>, IntegrationDeleteEventHandler<DeletedEvent<Step>, Step>>();
             services.AddTransient<IPublishEntityEventHelper<Step>, PublishEntityEventHelper<Step, StepEvent>>();
-            services.AddTransient<IPublishDeleteEntityEventHelper<Step>, PublishDeleteEntityEventHelper<Step, StepDeleteEvent>>();
             services.AddTransient<ICreateChildEventHelper<Journey, Step, StepEvent>, CreateJourneyStepEventHelper>();
             services.AddTransient<ICreateEventHelper<Step, StepEvent>, CreateStepEventHelper>();
-            services.AddTransient<ICreateEventHelper<Step, StepDeleteEvent>, CreateStepDeleteEventHelper>();
             
             services.AddTransient<IIntegrationEventPublisher, IntegrationEventPublisher>();
 
diff --git a/src/tests/Equinor.ProCoSys.Preservation.Command.Tests/EventHandlers/IntegrationEvents/CreateJourneyDeletedEventHelperTests.cs b/src/tests/Equinor.ProCoSys.Preservation.Command.Tests/EventHandlers/IntegrationEvents/CreateJourneyDeletedEventHelperTests.cs
@@ -0,0 +1,73 @@
+﻿using System.Linq;
+using Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents.EventHelpers;
+using Equinor.ProCoSys.Preservation.Command.Events;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.JourneyAggregate;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.ModeAggregate;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.ResponsibleAggregate;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Equinor.ProCoSys.Preservation.Command.Tests.EventHandlers.IntegrationEvents;
+
+[TestClass]
+public class CreateJourneyDeletedEventHelperTests
+{
+    private const string TestPlant = "PCS$PlantA";
+    private Journey _journey;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Arrange
+        _journey = new Journey(TestPlant, "Test Title");
+        
+        var mode = new Mode(TestPlant, "Test Title", true);
+        var responsible = new Responsible(TestPlant, "C", "Test Description");
+        
+        var step1 = new Step(TestPlant, "Test Title 1", mode, responsible);
+        _journey.AddStep(step1);
+        
+        var step2 = new Step(TestPlant, "Test Title 2", mode, responsible);
+        _journey.AddStep(step2);
+    }
+
+    [DataTestMethod]
+    [DataRow(nameof(JourneyDeleteEvent.Plant), TestPlant)]
+    [DataRow(nameof(JourneyDeleteEvent.ProjectName), null)]
+    [DataRow(nameof(JourneyDeleteEvent.Behavior), "delete")]
+    public void CreateEvent_ShouldCreateIntegrationEventExpectedValues(string property, object expected)
+    {
+        var deletionEvents = CreateJourneyDeletedEventHelper.CreateEvent(_journey);
+        var deletionEvent = deletionEvents.JourneyDeleteEvent;
+        var result = deletionEvent.GetType()
+            .GetProperties()
+            .Single(p => p.Name == property)
+            .GetValue(deletionEvent);
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+    
+    [TestMethod]
+    public void CreateEvent_ShouldCreateJourneyDeletedEventWithExpectedProCoSysGuid()
+    {
+        // Arrange
+        var expected = _journey.Guid;
+        
+        // Act
+        var deletedEvents = CreateJourneyDeletedEventHelper.CreateEvent(_journey);
+        var result = deletedEvents.JourneyDeleteEvent.ProCoSysGuid;
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+    
+    [TestMethod]
+    public void CreateEvent_ShouldCreateIntegrationEventsForChildSteps()
+    {
+        // Act
+        var integrationEvents = CreateJourneyDeletedEventHelper.CreateEvent(_journey);
+
+        // Assert
+        Assert.AreEqual(2, integrationEvents.StepDeleteEvents.Count());
+    }
+}
diff --git a/src/tests/Equinor.ProCoSys.Preservation.Command.Tests/EventHandlers/IntegrationEvents/CreateStepDeletedEventHelperTests.cs b/src/tests/Equinor.ProCoSys.Preservation.Command.Tests/EventHandlers/IntegrationEvents/CreateStepDeletedEventHelperTests.cs
@@ -0,0 +1,55 @@
+﻿using System.Linq;
+using Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents.EventHelpers;
+using Equinor.ProCoSys.Preservation.Command.Events;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.JourneyAggregate;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.ModeAggregate;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.ResponsibleAggregate;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Equinor.ProCoSys.Preservation.Command.Tests.EventHandlers.IntegrationEvents;
+
+[TestClass]
+public class CreateStepDeletedEventHelperTests
+{
+    private const string TestPlant = "PCS$PlantA";
+    private Step _step;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Arrange
+        var mode = new Mode(TestPlant, "Test Title", true);
+        var responsible = new Responsible(TestPlant, "C", "Test Description");
+        _step = new Step(TestPlant, "Test Title", mode, responsible);
+    }
+
+    [DataTestMethod]
+    [DataRow(nameof(StepDeleteEvent.Plant), TestPlant)]
+    [DataRow(nameof(StepDeleteEvent.ProjectName), null)]
+    [DataRow(nameof(StepDeleteEvent.Behavior), "delete")]
+    public void CreateEvent_ShouldCreateStepDeleteEventExpectedValues(string property, object expected)
+    {
+        var deletionEvent = CreateStepDeletedEventHelper.CreateEvent(_step);
+        var result = deletionEvent.GetType()
+            .GetProperties()
+            .Single(p => p.Name == property)
+            .GetValue(deletionEvent);
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+    
+    [TestMethod]
+    public void CreateEvent_ShouldCreateStepDeleteEventWithExpectedProCoSysGuid()
+    {
+        // Arrange
+        var expected = _step.Guid;
+        
+        // Act
+        var deletionEvent = CreateStepDeletedEventHelper.CreateEvent(_step);
+        var result = deletionEvent.ProCoSysGuid;
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+}
diff --git a/src/tests/Equinor.ProCoSys.Preservation.Command.Tests/EventHandlers/IntegrationEvents/JourneyDeletedEventHandlerTests.cs b/src/tests/Equinor.ProCoSys.Preservation.Command.Tests/EventHandlers/IntegrationEvents/JourneyDeletedEventHandlerTests.cs
@@ -0,0 +1,73 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Equinor.ProCoSys.Preservation.Command.EventHandlers.IntegrationEvents;
+using Equinor.ProCoSys.Preservation.Command.EventPublishers;
+using Equinor.ProCoSys.Preservation.Command.Events;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.JourneyAggregate;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.ModeAggregate;
+using Equinor.ProCoSys.Preservation.Domain.AggregateModels.ResponsibleAggregate;
+using Equinor.ProCoSys.Preservation.Domain.Events;
+using Equinor.ProCoSys.Preservation.MessageContracts;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace Equinor.ProCoSys.Preservation.Command.Tests.EventHandlers.IntegrationEvents;
+
+[TestClass]
+public class JourneyDeletedEventHandlerTests
+{
+    private const string TestPlant = "PCS$PlantA";
+    private JourneyDeletedEventHandler _dut;
+    private List<IIntegrationEvent> _publishedEvents;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Arrange
+        var mockPublisher = new Mock<IIntegrationEventPublisher>();
+        mockPublisher.Setup(x => x.PublishAsync(It.IsAny<IIntegrationEvent>(), default))
+            .Callback<IIntegrationEvent, CancellationToken>((e, _) => _publishedEvents.Add(e));
+
+        _publishedEvents = new List<IIntegrationEvent>();
+
+        _dut = new JourneyDeletedEventHandler(mockPublisher.Object);
+    }
+
+    [TestMethod]
+    public async Task Handle_ShouldSendIntegrationEvent()
+    {
+        // Arrange
+        var journey = new Journey(TestPlant, "Test Title");
+        var domainEvent = new DeletedEvent<Journey>(journey);
+
+        // Act
+        await _dut.Handle(domainEvent, default);
+        var types = _publishedEvents.Select(e => e.GetType()).ToList();
+
+        // Assert
+        CollectionAssert.Contains(types, typeof(JourneyDeleteEvent));
+    }
+    
+    [TestMethod]
+    public async Task Handle_ShouldSendStepDeleteEvent()
+    {
+        // Arrange
+        var journey = new Journey(TestPlant, "Test Title");
+        
+        var mode = new Mode(TestPlant, "Test Title", true);
+        var responsible = new Responsible(TestPlant, "C", "Test Description");
+        var step = new Step(TestPlant, "Test Title 1", mode, responsible);
+        journey.AddStep(step);
+        
+        var domainEvent = new DeletedEvent<Journey>(journey);
+
+        // Act
+        await _dut.Handle(domainEvent, default);
+        var types = _publishedEvents.Select(e => e.GetType()).ToList();
+
+        // Assert
+        CollectionAssert.Contains(types, typeof(StepDeleteEvent));
+    }
+}
diff --git a/src/tests/Equinor.ProCoSys.Preservation.Command.Tests/JourneyCommands/DeleteJourney/DeleteJourneyCommandHandlerTests.cs b/src/tests/Equinor.ProCoSys.Preservation.Command.Tests/JourneyCommands/DeleteJourney/DeleteJourneyCommandHandlerTests.cs
diff --git a/src/tests/Equinor.ProCoSys.Preservation.Domain.Tests/AggregateModels/JourneyAggregate/JourneyTests.cs b/src/tests/Equinor.ProCoSys.Preservation.Domain.Tests/AggregateModels/JourneyAggregate/JourneyTests.cs
diff --git a/src/tests/Equinor.ProCoSys.Preservation.Domain.Tests/AggregateModels/JourneyAggregate/StepTests.cs b/src/tests/Equinor.ProCoSys.Preservation.Domain.Tests/AggregateModels/JourneyAggregate/StepTests.cs

Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ public void RemoveStep(Step step)`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`_steps.Remove(step);`
`85`		`- step.SetRemoved();`
	`85`	`+ AddDomainEvent(new DeletedEvent<Step>(step));`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`public void SwapSteps(int stepId1, int stepId2)`
`@@ -202,7 +202,5 @@ public void SetModified(Person modifiedBy)`
`202`	`202`
`203`	`203`	`AddDomainEvent(new ModifiedEvent<Journey>(this));`
`204`	`204`	`}`
`205`		`-`
`206`		`- public void SetRemoved() => AddDomainEvent(new DeletedEvent<Journey>(this));`
`207`	`205`	`}`
`208`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,5 @@ public void SetResponsible(Responsible responsible)`
`120`	`120`
`121`	`121`	`AddDomainEvent(new ModifiedEvent<Step>(this));`
`122`	`122`	`}`
`123`		`-`
`124`		`- public void SetRemoved() => AddDomainEvent(new DeletedEvent<Step>(this));`
`125`	`123`	`}`
`126`	`124`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,21 +29,15 @@ public Task<List<Journey>> GetJourneysWithAutoTransferStepsAsync(AutoTransferMet`
`29`	`29`	`.Where(journey => journey.Steps.Any(s => s.AutoTransferMethod == autoTransferMethod))`
`30`	`30`	`.ToListAsync();`
`31`	`31`
`32`		`- public void RemoveStep(Step step)`
`33`		`- {`
`34`		`- _context.Steps.Remove(step);`
`35`		`- step.SetRemoved();`
`36`		`- }`
	`32`	`+ public void RemoveStep(Step step) => _context.Steps.Remove(step);`
`37`	`33`
`38`	`34`	`public override void Remove(Journey journey)`
`39`	`35`	`{`
`40`	`36`	`foreach (var step in journey.Steps)`
`41`	`37`	`{`
`42`	`38`	`_context.Steps.Remove(step);`
`43`		`- step.SetRemoved();`
`44`	`39`	`}`
`45`	`40`	`base.Remove(journey);`
`46`		`- journey.SetRemoved();`
`47`	`41`	`}`
`48`	`42`	`}`
`49`	`43`	`}`