fix: completion of building was not registered in all cases

Author: Arne Dumarey

…Detail/BuildingUnitBuildingOsloIdItem.cs …ngUnitDetail/BuildingUnitBuildingItem.cssrc/BuildingRegistry.Projections.Legacy/BuildingUnitDetail/BuildingUnitBuildingOsloIdItem.cs renamed to src/BuildingRegistry.Projections.Legacy/BuildingUnitDetail/BuildingUnitBuildingItem.cs src/BuildingRegistry.Projections.Legacy/BuildingUnitDetail/BuildingUnitBuildingOsloIdItem.cs renamed to src/BuildingRegistry.Projections.Legacy/BuildingUnitDetail/BuildingUnitBuildingItem.cs

@@ -4,23 +4,32 @@ namespace BuildingRegistry.Projections.Legacy.BuildingUnitDetail
     using Infrastructure;
     using Microsoft.EntityFrameworkCore;
     using Microsoft.EntityFrameworkCore.Metadata.Builders;
+    using ValueObjects;
 
-    public class BuildingUnitBuildingOsloIdItem
+    public class BuildingUnitBuildingItem
     {
         public Guid BuildingId { get; set; }
         public int? BuildingOsloId { get; set; }
+        public bool? IsComplete { get; set; }
+        public bool IsRemoved { get; set; }
+        public BuildingStatus? BuildingRetiredStatus { get; set; }
     }
 
-    public class BuildingUnitBuildingOsloIdItemConfiguration : IEntityTypeConfiguration<BuildingUnitBuildingOsloIdItem>
+    public class BuildingUnitBuildingOsloIdItemConfiguration : IEntityTypeConfiguration<BuildingUnitBuildingItem>
     {
-        public const string TableName = "BuildingUnit_BuildingOsloIds";
+        public const string TableName = "BuildingUnit_Buildings";
 
-        public void Configure(EntityTypeBuilder<BuildingUnitBuildingOsloIdItem> b)
+        public void Configure(EntityTypeBuilder<BuildingUnitBuildingItem> b)
         {
             b.ToTable(TableName, Schema.Legacy)
                 .HasKey(p => p.BuildingId)
                 .ForSqlServerIsClustered(false);
 
+            b.Property(p => p.IsComplete);
+            b.Property(p => p.IsRemoved);
+            b.Property(p => p.BuildingOsloId);
+            b.Property(p => p.BuildingRetiredStatus);
+
             b.HasIndex(p => p.BuildingOsloId);
         }
     }

src/BuildingRegistry.Projections.Legacy/BuildingUnitDetail/BuildingUnitDetailProjections.cs

@@ -24,6 +24,18 @@ public BuildingUnitDetailProjections(WKBReader wkbReader)
             _wkbReader = wkbReader;
 
             #region Building
+            When<Envelope<BuildingWasRegistered>>(async (context, message, ct) =>
+                {
+                    await context
+                        .BuildingUnitBuildings
+                        .AddAsync(
+                            new BuildingUnitBuildingItem
+                            {
+                                BuildingId = message.Message.BuildingId,
+                                IsRemoved = false
+                            }, ct);
+                });
+
             When<Envelope<BuildingWasRemoved>>(async (context, message, ct) =>
             {
                 // possible of ALOT of units, might exceed SQL server IN (...) limitation, thats why we first get id by BuildingId
@@ -43,30 +55,45 @@ public BuildingUnitDetailProjections(WKBReader wkbReader)
                         SetVersion(buildingUnitDetailItem, message.Message.Provenance.Timestamp);
                     }
                 }
+
+                var building = await context.BuildingUnitBuildings.FindAsync(message.Message.BuildingId, cancellationToken: ct);
+                building.IsRemoved = true;
             });
 
             When<Envelope<BuildingWasRetired>>(async (context, message, ct) =>
             {
                 var buildingUnits = await context.BuildingUnitDetails.Where(unit => unit.BuildingId == message.Message.BuildingId).ToListAsync(ct);
                 RetireUnitsByBuilding(buildingUnits, message.Message.BuildingUnitIdsToNotRealize, message.Message.BuildingUnitIdsToRetire, message.Message.Provenance.Timestamp);
+
+                var building = await context.BuildingUnitBuildings.FindAsync(message.Message.BuildingId, cancellationToken: ct);
+                building.BuildingRetiredStatus = BuildingStatus.Retired;
             });
 
             When<Envelope<BuildingWasCorrectedToRetired>>(async (context, message, ct) =>
             {
                 var buildingUnits = await context.BuildingUnitDetails.Where(unit => unit.BuildingId == message.Message.BuildingId).ToListAsync(ct);
                 RetireUnitsByBuilding(buildingUnits, message.Message.BuildingUnitIdsToNotRealize, message.Message.BuildingUnitIdsToRetire, message.Message.Provenance.Timestamp);
+
+                var building = await context.BuildingUnitBuildings.FindAsync(message.Message.BuildingId, cancellationToken: ct);
+                building.BuildingRetiredStatus = BuildingStatus.Retired;
             });
 
             When<Envelope<BuildingWasNotRealized>>(async (context, message, ct) =>
             {
                 var buildingUnits = await context.BuildingUnitDetails.Where(unit => unit.BuildingId == message.Message.BuildingId).ToListAsync(ct);
                 RetireUnitsByBuilding(buildingUnits, message.Message.BuildingUnitIdsToNotRealize, message.Message.BuildingUnitIdsToRetire, message.Message.Provenance.Timestamp);
+
+                var building = await context.BuildingUnitBuildings.FindAsync(message.Message.BuildingId, cancellationToken: ct);
+                building.BuildingRetiredStatus = BuildingStatus.NotRealized;
             });
 
             When<Envelope<BuildingWasCorrectedToNotRealized>>(async (context, message, ct) =>
             {
                 var buildingUnits = await context.BuildingUnitDetails.Where(unit => unit.BuildingId == message.Message.BuildingId).ToListAsync(ct);
                 RetireUnitsByBuilding(buildingUnits, message.Message.BuildingUnitIdsToNotRealize, message.Message.BuildingUnitIdsToRetire, message.Message.Provenance.Timestamp);
+
+                var building = await context.BuildingUnitBuildings.FindAsync(message.Message.BuildingId, cancellationToken: ct);
+                building.BuildingRetiredStatus = BuildingStatus.NotRealized;
             });
 
             When<Envelope<BuildingGeometryWasRemoved>>(async (context, message, ct) =>
@@ -88,6 +115,9 @@ public BuildingUnitDetailProjections(WKBReader wkbReader)
                     buildingUnit.IsBuildingComplete = true;
                     SetVersion(buildingUnit, message.Message.Provenance.Timestamp);
                 }
+
+                var building = await context.BuildingUnitBuildings.FindAsync(message.Message.BuildingId, cancellationToken: ct);
+                building.IsComplete = true;
             });
 
             When<Envelope<BuildingBecameIncomplete>>(async (context, message, ct) =>
@@ -98,17 +128,15 @@ public BuildingUnitDetailProjections(WKBReader wkbReader)
                     buildingUnit.IsBuildingComplete = false;
                     SetVersion(buildingUnit, message.Message.Provenance.Timestamp);
                 }
+
+                var building = await context.BuildingUnitBuildings.FindAsync(message.Message.BuildingId, cancellationToken: ct);
+                building.IsComplete = false;
             });
 
             When<Envelope<BuildingOsloIdWasAssigned>>(async (context, message, ct) =>
             {
-                await context
-                    .BuildingUnitBuildingOsloIds
-                    .AddAsync(new BuildingUnitBuildingOsloIdItem
-                    {
-                        BuildingId = message.Message.BuildingId,
-                        BuildingOsloId = message.Message.OsloId,
-                    }, cancellationToken: ct);
+                var building = await context.BuildingUnitBuildings.FindAsync(message.Message.BuildingId, cancellationToken: ct);
+                building.BuildingOsloId = message.Message.OsloId;
 
                 foreach (var buildingUnit in context
                     .BuildingUnitDetails
@@ -384,15 +412,16 @@ private static async Task AddUnit(LegacyContext context,
             bool isCommon,
             CancellationToken ct)
         {
-            var buildingOsloId = await context
-                .BuildingUnitBuildingOsloIds
+            var building = await context
+                .BuildingUnitBuildings
                 .FindAsync(buildingId, cancellationToken: ct);
 
             var buildingUnitDetailItem = new BuildingUnitDetailItem
             {
                 BuildingUnitId = buildingUnitId,
                 BuildingId = buildingId,
-                BuildingOsloId = buildingOsloId?.BuildingOsloId,
+                BuildingOsloId = building?.BuildingOsloId,
+                IsBuildingComplete = building?.IsComplete ?? false,
                 Version = version,
                 Function = isCommon ? BuildingUnitFunction.Common : BuildingUnitFunction.Unknown,
             };

src/BuildingRegistry.Projections.Legacy/LegacyContext.cs

@@ -18,7 +18,7 @@ public class LegacyContext : RunnerDbContext<LegacyContext>
         public DbSet<BuildingDetailItem> BuildingDetails { get; set; }
         public DbSet<BuildingSyndicationItem> BuildingSyndication { get; set; }
         public DbSet<BuildingUnitDetailItem> BuildingUnitDetails { get; set; }
-        public DbSet<BuildingUnitBuildingOsloIdItem> BuildingUnitBuildingOsloIds { get; set; }
+        public DbSet<BuildingUnitBuildingItem> BuildingUnitBuildings { get; set; }
         public DbSet<BuildingUnitDetailAddressItem> BuildingUnitAddresses { get; set; }
 
         public LegacyContext() { }