feat: add StreetNameWasRenamed event

src/AddressRegistry.Consumer/Projections/StreetNameKafkaProjection.cs

@@ -179,6 +179,7 @@ await commandHandler.Handle(
 
                 var retireStreetNameBecauseOfRename = new RetireStreetNameBecauseOfRename(
                     new StreetNamePersistentLocalId(message.PersistentLocalId),
+                    new StreetNamePersistentLocalId(message.DestinationPersistentLocalId),
                     FromProvenance(message.Provenance));
 
                 await commandHandler.Handle(retireStreetNameBecauseOfRename, ct);

src/AddressRegistry.Producer/Extensions/MessageExtensions.cs

@@ -246,27 +246,6 @@ public static Contracts.AddressWasCorrectedFromRejectedToProposed ToContract(thi
                 message.AddressPersistentLocalId,
                 message.Provenance.ToContract());
 
-        public static Contracts.MigratedStreetNameWasImported ToContract(this StreetNameAggregate.MigratedStreetNameWasImported message) =>
-            new Contracts.MigratedStreetNameWasImported(
-                message.StreetNameId.ToString("D"),
-                message.StreetNamePersistentLocalId,
-                message.MunicipalityId.ToString("D"),
-                message.NisCode,
-                message.StreetNameStatus.ToString(),
-                message.Provenance.ToContract());
-
-        public static Contracts.StreetNameWasApproved ToContract(this StreetNameAggregate.StreetNameWasApproved message) =>
-            new Contracts.StreetNameWasApproved(message.StreetNamePersistentLocalId, message.Provenance.ToContract());
-
-        public static Contracts.StreetNameWasRetired ToContract(this StreetNameAggregate.StreetNameWasRetired message) =>
-            new Contracts.StreetNameWasRetired(message.StreetNamePersistentLocalId, message.Provenance.ToContract());
-
-        public static Contracts.StreetNameWasImported ToContract(this StreetNameAggregate.StreetNameWasImported message) =>
-            new Contracts.StreetNameWasImported(message.StreetNamePersistentLocalId, message.MunicipalityId.ToString("D"), message.StreetNameStatus.ToString(), message.Provenance.ToContract());
-
-        public static Contracts.StreetNameWasRemoved ToContract(this StreetNameAggregate.StreetNameWasRemoved message) =>
-            new Contracts.StreetNameWasRemoved(message.StreetNamePersistentLocalId, message.Provenance.ToContract());
-
         public static Contracts.AddressRegularizationWasCorrected ToContract(this StreetNameAggregate.AddressRegularizationWasCorrected message) =>
             new Contracts.AddressRegularizationWasCorrected(message.StreetNamePersistentLocalId, message.AddressPersistentLocalId, message.Provenance.ToContract());
 

src/AddressRegistry/StreetName/Commands/RetireStreetNameBecauseOfRename.cs

@@ -11,13 +11,17 @@ public class RetireStreetNameBecauseOfRename : IHasCommandProvenance
         private static readonly Guid Namespace = new Guid("32e8aabd-67fb-4b59-9071-de2b226f701b");
 
         public StreetNamePersistentLocalId PersistentLocalId { get; }
+        public StreetNamePersistentLocalId DestinationPersistentLocalId { get; set; }
+
         public Provenance Provenance { get; }
 
         public RetireStreetNameBecauseOfRename(
             StreetNamePersistentLocalId persistentLocalId,
+            StreetNamePersistentLocalId destinationPersistentLocalId,
             Provenance provenance)
         {
             PersistentLocalId = persistentLocalId;
+            DestinationPersistentLocalId = destinationPersistentLocalId;
             Provenance = provenance;
         }
 
@@ -30,6 +34,7 @@ public Guid CreateCommandId()
         private IEnumerable<object> IdentityFields()
         {
             yield return PersistentLocalId;
+            yield return DestinationPersistentLocalId;
 
             foreach (var field in Provenance.GetIdentityFields())
             {

src/AddressRegistry/StreetName/Events/StreetNameWasRenamed.cs

@@ -0,0 +1,52 @@
+namespace AddressRegistry.StreetName.Events
+{
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Linq;
+    using Be.Vlaanderen.Basisregisters.EventHandling;
+    using Be.Vlaanderen.Basisregisters.GrAr.Common;
+    using Be.Vlaanderen.Basisregisters.GrAr.Provenance;
+    using Newtonsoft.Json;
+
+    [EventTags(Tag.StreetName)]
+    [EventName(EventName)]
+    [EventDescription("De straatnaam werd hernoemd.")]
+    public class StreetNameWasRenamed : IStreetNameEvent
+    {
+        public const string EventName = "StreetNameWasRenamed"; // BE CAREFUL CHANGING THIS!!
+
+        public int StreetNamePersistentLocalId { get; }
+        public int DestinationStreetNamePersistentLocalId { get; }
+        public ProvenanceData Provenance { get; private set; }
+
+        public StreetNameWasRenamed(
+            StreetNamePersistentLocalId streetNamePersistentLocalId,
+            StreetNamePersistentLocalId destinationStreetNamePersistentLocalId)
+        {
+            StreetNamePersistentLocalId = streetNamePersistentLocalId;
+            DestinationStreetNamePersistentLocalId = destinationStreetNamePersistentLocalId;
+        }
+
+        [JsonConstructor]
+        private StreetNameWasRenamed(
+            int streetNamePersistentLocalId,
+            int destinationStreetNamePersistentLocalId,
+            ProvenanceData provenance)
+            : this(
+                new StreetNamePersistentLocalId(streetNamePersistentLocalId),
+                new StreetNamePersistentLocalId(destinationStreetNamePersistentLocalId))
+            => ((ISetProvenance)this).SetProvenance(provenance.ToProvenance());
+
+        void ISetProvenance.SetProvenance(Provenance provenance) => Provenance = new ProvenanceData(provenance);
+
+        public IEnumerable<string> GetHashFields()
+        {
+            var fields = Provenance.GetHashFields().ToList();
+            fields.Add(StreetNamePersistentLocalId.ToString(CultureInfo.InvariantCulture));
+            fields.Add(DestinationStreetNamePersistentLocalId.ToString(CultureInfo.InvariantCulture));
+            return fields;
+        }
+
+        public string GetHash() => this.ToEventHash(EventName);
+    }
+}

src/AddressRegistry/StreetName/StreetName.cs

@@ -194,14 +194,14 @@ private static void RetireAddressesBecauseStreetNameWasRetired(IEnumerable<Stree
             }
         }
 
-        public void RetireStreetNameBecauseOfRename()
+        public void RetireStreetNameBecauseOfRename(StreetNamePersistentLocalId destinationPersistentLocalId)
         {
             foreach (var address in StreetNameAddresses)
             {
                 RejectOrRetireAddressForReaddress(address.AddressPersistentLocalId);
             }
 
-            ApplyChange(new StreetNameWasRetired(PersistentLocalId));
+            ApplyChange(new StreetNameWasRenamed(PersistentLocalId, destinationPersistentLocalId));
         }
 
         #region Metadata

src/AddressRegistry/StreetName/StreetNameCommandHandlerModule.cs

@@ -200,7 +200,7 @@ public StreetNameCommandHandlerModule(
                     var streetNameStreamId = new StreetNameStreamId(message.Command.PersistentLocalId);
                     var streetName = await getStreetNames().GetAsync(streetNameStreamId, ct);
 
-                    streetName.RetireStreetNameBecauseOfRename();
+                    streetName.RetireStreetNameBecauseOfRename(message.Command.DestinationPersistentLocalId);
                 });
         }
     }

src/AddressRegistry/StreetName/StreetName_State.cs

@@ -29,6 +29,7 @@ private StreetName()
             Register<StreetNameWasApproved>(When);
             Register<StreetNameWasRejected>(When);
             Register<StreetNameWasRetired>(When);
+            Register<StreetNameWasRenamed>(When);
             Register<StreetNameWasRemoved>(When);
             Register<StreetNameNamesWereCorrected>(When);
             Register<StreetNameHomonymAdditionsWereCorrected>(When);
@@ -131,6 +132,11 @@ private void When(StreetNameWasRetired @event)
             Status = StreetNameStatus.Retired;
         }
 
+        private void When(StreetNameWasRenamed @event)
+        {
+            Status = StreetNameStatus.Retired;
+        }
+
         private void When(StreetNameWasRemoved @event)
         {
             IsRemoved = true;

test/AddressRegistry.Tests/AggregateTests/WhenRetiringStreetNameBecauseOfRename/GivenStreetName.cs

@@ -1,9 +1,13 @@
 namespace AddressRegistry.Tests.AggregateTests.WhenRetiringStreetNameBecauseOfRename
 {
+    using System.Collections.Generic;
     using AutoFixture;
     using Be.Vlaanderen.Basisregisters.AggregateSource;
+    using Be.Vlaanderen.Basisregisters.AggregateSource.Snapshotting;
     using Be.Vlaanderen.Basisregisters.AggregateSource.Testing;
+    using Be.Vlaanderen.Basisregisters.GrAr.Provenance;
     using EventExtensions;
+    using FluentAssertions;
     using global::AutoFixture;
     using StreetName;
     using StreetName.Commands;
@@ -28,10 +32,13 @@ public void ThenAddressesWereRetiredOrRejectedAndStreetNameWasRetired()
         {
             var streetNamePersistentLocalId = Fixture.Create<StreetNamePersistentLocalId>();
 
-            var command = Fixture.Create<RetireStreetNameBecauseOfRename>();
+            var command = new RetireStreetNameBecauseOfRename(
+                streetNamePersistentLocalId,
+                new StreetNamePersistentLocalId(streetNamePersistentLocalId + 1),
+                Fixture.Create<Provenance>());
 
             var streetNameWasImported = Fixture.Create<StreetNameWasImported>()
-                    .WithStatus(StreetNameStatus.Current);
+                .WithStatus(StreetNameStatus.Current);
 
             var proposedAddress = Fixture.Create<AddressWasProposedV2>()
                 .AsHouseNumberAddress();
@@ -47,22 +54,27 @@ public void ThenAddressesWereRetiredOrRejectedAndStreetNameWasRetired()
                 .When(command)
                 .Then(
                     new Fact(new StreetNameStreamId(command.PersistentLocalId),
-                        new AddressWasRejectedBecauseOfReaddress(streetNamePersistentLocalId, new AddressPersistentLocalId(proposedAddress.AddressPersistentLocalId))),
+                        new AddressWasRejectedBecauseOfReaddress(streetNamePersistentLocalId,
+                            new AddressPersistentLocalId(proposedAddress.AddressPersistentLocalId))),
                     new Fact(new StreetNameStreamId(command.PersistentLocalId),
-                        new AddressWasRetiredBecauseOfReaddress(streetNamePersistentLocalId, new AddressPersistentLocalId(currentAddress.AddressPersistentLocalId))),
+                        new AddressWasRetiredBecauseOfReaddress(streetNamePersistentLocalId,
+                            new AddressPersistentLocalId(currentAddress.AddressPersistentLocalId))),
                     new Fact(new StreetNameStreamId(command.PersistentLocalId),
-                        new StreetNameWasRetired(streetNamePersistentLocalId))));
+                        new StreetNameWasRenamed(streetNamePersistentLocalId, command.DestinationPersistentLocalId))));
         }
 
         [Fact]
         public void WithInActiveAddresses_ThenStreetNameWasRetired()
         {
             var streetNamePersistentLocalId = Fixture.Create<StreetNamePersistentLocalId>();
 
-            var command = Fixture.Create<RetireStreetNameBecauseOfRename>();
+            var command = new RetireStreetNameBecauseOfRename(
+                streetNamePersistentLocalId,
+                new StreetNamePersistentLocalId(streetNamePersistentLocalId + 1),
+                Fixture.Create<Provenance>());
 
             var streetNameWasImported = Fixture.Create<StreetNameWasImported>()
-                    .WithStatus(StreetNameStatus.Current);
+                .WithStatus(StreetNameStatus.Current);
 
             var retiredAddress = Fixture.Create<AddressWasMigratedToStreetName>()
                 .AsHouseNumberAddress()
@@ -83,7 +95,30 @@ public void WithInActiveAddresses_ThenStreetNameWasRetired()
                     removedAddress)
                 .When(command)
                 .Then(new Fact(new StreetNameStreamId(command.PersistentLocalId),
-                        new StreetNameWasRetired(streetNamePersistentLocalId))));
+                    new StreetNameWasRenamed(streetNamePersistentLocalId, command.DestinationPersistentLocalId))));
+        }
+
+        [Fact]
+        public void StateCheck()
+        {
+            // Arrange
+            var streetNamePersistentLocalId = Fixture.Create<StreetNamePersistentLocalId>();
+            var destinationStreetNamePersistentLocalId = new StreetNamePersistentLocalId(streetNamePersistentLocalId + 1);
+
+            var migratedStreetNameWasImported = Fixture.Create<MigratedStreetNameWasImported>()
+                .WithStatus(StreetNameStatus.Current);
+
+            var sut = new StreetNameFactory(NoSnapshotStrategy.Instance).Create();
+            sut.Initialize(new List<object>
+            {
+                migratedStreetNameWasImported,
+                new StreetNameWasRenamed(
+                    streetNamePersistentLocalId,
+                    destinationStreetNamePersistentLocalId)
+            });
+
+            // Assert
+            sut.Status.Should().Be(StreetNameStatus.Retired);
         }
     }
 }