feat: add remove measured building

Author: ArneD

src/BuildingRegistry.Api.BackOffice.Abstractions/Building/Requests/RemoveMeasuredBuildingRequest.cs

@@ -0,0 +1,7 @@
+namespace BuildingRegistry.Api.BackOffice.Abstractions.Building.Requests
+{
+    public sealed class RemoveMeasuredBuildingRequest
+    {
+        public int PersistentLocalId { get; set; }
+    }
+}

src/BuildingRegistry.Api.BackOffice.Abstractions/Building/SqsRequests/RemoveMeasuredBuildingSqsRequest.cs

@@ -0,0 +1,10 @@
+namespace BuildingRegistry.Api.BackOffice.Abstractions.Building.SqsRequests
+{
+    using Be.Vlaanderen.Basisregisters.Sqs.Requests;
+    using Requests;
+
+    public sealed class RemoveMeasuredBuildingSqsRequest : SqsRequest
+    {
+        public RemoveMeasuredBuildingRequest Request { get; set; }
+    }
+}

src/BuildingRegistry.Api.BackOffice.Abstractions/Validation/RemoveMeasuredBuilding.cs

@@ -0,0 +1,26 @@
+namespace BuildingRegistry.Api.BackOffice.Abstractions.Validation
+{
+    using TicketingService.Abstractions;
+
+    public static partial class ValidationErrors
+    {
+        public static class RemoveMeasuredBuilding
+        {
+            public static class BuildingHasInvalidBuildingGeometryMethod
+            {
+                public const string Code = "GebouwGeometrieMethodeIngeschetst";
+                public const string Message = "Deze actie is enkel toegestaan op gebouwen met geometrieMethode 'ingemeten'.";
+
+                public static TicketError ToTicketError() => new(Message, Code);
+            }
+
+            public static class BuildingHasBuildingUnits
+            {
+                public const string Code = "GebouwHeeftGebouweenheden";
+                public const string Message = "Deze actie is enkel toegestaan op gebouwen zonder gebouweenheden.";
+
+                public static TicketError ToTicketError() => new(Message, Code);
+            }
+        }
+    }
+}

src/BuildingRegistry.Api.BackOffice.Handlers.Lambda/Handlers/Building/RemoveMeasuredBuildingLambdaHandler.cs

@@ -0,0 +1,69 @@
+namespace BuildingRegistry.Api.BackOffice.Handlers.Lambda.Handlers.Building
+{
+    using Abstractions;
+    using Abstractions.Validation;
+    using Be.Vlaanderen.Basisregisters.AggregateSource;
+    using Be.Vlaanderen.Basisregisters.CommandHandling.Idempotency;
+    using Be.Vlaanderen.Basisregisters.Sqs.Lambda.Infrastructure;
+    using Be.Vlaanderen.Basisregisters.Sqs.Responses;
+    using BuildingRegistry.Building;
+    using BuildingRegistry.Building.Exceptions;
+    using Microsoft.Extensions.Configuration;
+    using Requests.Building;
+    using TicketingService.Abstractions;
+
+    public sealed class RemoveMeasuredBuildingLambdaHandler : BuildingLambdaHandler<RemoveMeasuredBuildingLambdaRequest>
+    {
+        private readonly BackOfficeContext _backOfficeContext;
+
+        public RemoveMeasuredBuildingLambdaHandler(
+            IConfiguration configuration,
+            ICustomRetryPolicy retryPolicy,
+            ITicketing ticketing,
+            IIdempotentCommandHandler idempotentCommandHandler,
+            IBuildings buildings,
+            BackOfficeContext backOfficeContext)
+            : base(
+                configuration,
+                retryPolicy,
+                ticketing,
+                idempotentCommandHandler,
+                buildings)
+        {
+            _backOfficeContext = backOfficeContext;
+        }
+
+        protected override async Task<object> InnerHandle(RemoveMeasuredBuildingLambdaRequest request, CancellationToken cancellationToken)
+        {
+            var cmd = request.ToCommand();
+
+            try
+            {
+                await IdempotentCommandHandler.Dispatch(
+                    cmd.CreateCommandId(),
+                    cmd,
+                    request.Metadata,
+                    cancellationToken);
+            }
+            catch (IdempotencyException)
+            {
+                // Idempotent: Do Nothing return last etag
+            }
+
+            await _backOfficeContext.RemoveBuildingUnitAddressRelations(cmd.BuildingPersistentLocalId, cancellationToken);
+
+            var lastHash = await GetHash(new BuildingPersistentLocalId(request.BuildingPersistentLocalId), cancellationToken);
+            return new ETagResponse(string.Format(DetailUrlFormat, request.BuildingPersistentLocalId), lastHash);
+        }
+
+        protected override TicketError? InnerMapDomainException(DomainException exception, RemoveMeasuredBuildingLambdaRequest request)
+        {
+            return exception switch
+            {
+                BuildingHasInvalidGeometryMethodException => ValidationErrors.RemoveMeasuredBuilding.BuildingHasInvalidBuildingGeometryMethod.ToTicketError(),
+                BuildingHasBuildingUnitsException => ValidationErrors.RemoveMeasuredBuilding.BuildingHasBuildingUnits.ToTicketError(),
+                _ => null
+            };
+        }
+    }
+}

src/BuildingRegistry.Api.BackOffice.Handlers.Lambda/MessageHandler.cs

@@ -114,6 +114,10 @@ public async Task HandleMessage(object? messageData, MessageMetadata messageMeta
                     await mediator.Send(new RemoveBuildingUnitLambdaRequest(messageMetadata.MessageGroupId!, request), cancellationToken);
                     break;
 
+                case RemoveMeasuredBuildingSqsRequest request:
+                    await mediator.Send(new RemoveMeasuredBuildingLambdaRequest(messageMetadata.MessageGroupId!, request), cancellationToken);
+                    break;
+
                 case DeregulateBuildingUnitSqsRequest request:
                     await mediator.Send(new DeregulateBuildingUnitLambdaRequest(messageMetadata.MessageGroupId!, request), cancellationToken);
                     break;

src/BuildingRegistry.Api.BackOffice.Handlers.Lambda/Requests/Building/RemoveMeasuredBuildingLambdaRequest.cs

@@ -0,0 +1,34 @@
+namespace BuildingRegistry.Api.BackOffice.Handlers.Lambda.Requests.Building
+{
+    using Abstractions.Building.SqsRequests;
+    using BuildingRegistry.Api.BackOffice.Abstractions.Building.Requests;
+    using BuildingRegistry.Building;
+    using BuildingRegistry.Building.Commands;
+
+    public sealed record RemoveMeasuredBuildingLambdaRequest : BuildingLambdaRequest, Abstractions.IHasBuildingPersistentLocalId
+    {
+        public RemoveMeasuredBuildingRequest Request { get; }
+
+        public int BuildingPersistentLocalId => Request.PersistentLocalId;
+
+        public RemoveMeasuredBuildingLambdaRequest(string messageGroupId, RemoveMeasuredBuildingSqsRequest sqsRequest)
+            : base(
+                messageGroupId,
+                sqsRequest.TicketId,
+                sqsRequest.IfMatchHeaderValue,
+                sqsRequest.ProvenanceData!.ToProvenance(),
+                sqsRequest.Metadata)
+        {
+            Request = sqsRequest.Request;
+        }
+
+        /// <summary>
+        /// Map to RemoveMeasuredBuilding command.
+        /// </summary>
+        /// <returns>RemoveMeasuredBuilding.</returns>
+        public RemoveMeasuredBuilding ToCommand()
+        {
+            return new RemoveMeasuredBuilding(new BuildingPersistentLocalId(BuildingPersistentLocalId), Provenance);
+        }
+    }
+}

src/BuildingRegistry.Api.BackOffice/Building/BuildingController-RemoveMeasured.cs

@@ -0,0 +1,72 @@
+namespace BuildingRegistry.Api.BackOffice.Building
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Abstractions.Building.Requests;
+    using Abstractions.Building.Validators;
+    using Abstractions.Building.SqsRequests;
+    using Abstractions.Validation;
+    using Be.Vlaanderen.Basisregisters.Auth.AcmIdm;
+    using Be.Vlaanderen.Basisregisters.Api.ETag;
+    using Be.Vlaanderen.Basisregisters.Api.Exceptions;
+    using Be.Vlaanderen.Basisregisters.GrAr.Provenance;
+    using BuildingRegistry.Building;
+    using Infrastructure;
+    using Microsoft.AspNetCore.Authentication.JwtBearer;
+    using Microsoft.AspNetCore.Authorization;
+    using Microsoft.AspNetCore.Http;
+    using Microsoft.AspNetCore.Mvc;
+    using Swashbuckle.AspNetCore.Filters;
+
+    public partial class BuildingController
+    {
+        /// <summary>
+        /// Ingemeten gebouw verwijderen.
+        /// </summary>
+        /// <param name="buildingExistsValidator"></param>
+        /// <param name="ifMatchHeaderValidator"></param>
+        /// <param name="request"></param>
+        /// <param name="ifMatchHeaderValue"></param>
+        /// <param name="cancellationToken"></param>
+        /// <response code="202">Aanvraag tot goedkeuring wordt reeds verwerkt.</response>
+        /// <response code="412">Als de If-Match header niet overeenkomt met de laatste ETag.</response>
+        /// <returns></returns>
+        [HttpPost("{persistentLocalId}/acties/verwijder-ingemeten")]
+        [ProducesResponseType(StatusCodes.Status202Accepted)]
+        [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status500InternalServerError)]
+        [SwaggerResponseHeader(StatusCodes.Status202Accepted, "location", "string", "De URL van het aangemaakte ticket.")]
+        [SwaggerResponseExample(StatusCodes.Status400BadRequest, typeof(BadRequestResponseExamples))]
+        [SwaggerResponseExample(StatusCodes.Status500InternalServerError, typeof(InternalServerErrorResponseExamples))]
+        [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme, Policy = PolicyNames.IngemetenGebouw.GrbBijwerker)]
+        [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme, Policy = PolicyNames.IngemetenGebouw.InterneBijwerker)]
+        public async Task<IActionResult> RemoveMeasuredBuilding(
+            [FromServices] BuildingExistsValidator buildingExistsValidator,
+            [FromServices] IIfMatchHeaderValidator ifMatchHeaderValidator,
+            [FromRoute] RemoveMeasuredBuildingRequest request,
+            [FromHeader(Name = "If-Match")] string? ifMatchHeaderValue,
+            CancellationToken cancellationToken = default)
+        {
+            if (!await buildingExistsValidator.Exists(new BuildingPersistentLocalId(request.PersistentLocalId), cancellationToken))
+            {
+                throw new ApiException(ValidationErrors.Common.BuildingNotFound.Message, StatusCodes.Status404NotFound);
+            }
+
+            if (!await ifMatchHeaderValidator.IsValidForBuilding(ifMatchHeaderValue, new BuildingPersistentLocalId(request.PersistentLocalId), cancellationToken))
+            {
+                return new PreconditionFailedResult();
+            }
+
+            var sqsResult = await Mediator.Send(
+                new RemoveMeasuredBuildingSqsRequest
+                {
+                    Request = request,
+                    Metadata = GetMetadata(),
+                    ProvenanceData = new ProvenanceData(CreateProvenance(Modification.Delete)),
+                    IfMatchHeaderValue = ifMatchHeaderValue
+                }, cancellationToken);
+
+            return Accepted(sqsResult);
+        }
+    }
+}

src/BuildingRegistry.Api.BackOffice/Handlers/Building/RemoveMeasuredBuildingSqsHandler.cs

@@ -0,0 +1,37 @@
+namespace BuildingRegistry.Api.BackOffice.Handlers.Building
+{
+    using System.Collections.Generic;
+    using Abstractions.Building.SqsRequests;
+    using Be.Vlaanderen.Basisregisters.Sqs;
+    using Be.Vlaanderen.Basisregisters.Sqs.Handlers;
+    using TicketingService.Abstractions;
+
+    public sealed class RemoveMeasuredBuildingSqsHandler : SqsHandler<RemoveMeasuredBuildingSqsRequest>
+    {
+        public const string Action = "RemoveMeasuredBuilding";
+
+        public RemoveMeasuredBuildingSqsHandler(
+            ISqsQueue sqsQueue,
+            ITicketing ticketing,
+            ITicketingUrl ticketingUrl)
+            : base(sqsQueue, ticketing, ticketingUrl)
+        {
+        }
+
+        protected override string WithAggregateId(RemoveMeasuredBuildingSqsRequest request)
+        {
+            return request.Request.PersistentLocalId.ToString();
+        }
+
+        protected override IDictionary<string, string> WithTicketMetadata(string aggregateId, RemoveMeasuredBuildingSqsRequest sqsRequest)
+        {
+            return new Dictionary<string, string>
+            {
+                { RegistryKey, nameof(BuildingRegistry) },
+                { ActionKey, Action },
+                { AggregateIdKey, aggregateId },
+                { ObjectIdKey, sqsRequest.Request.PersistentLocalId.ToString() }
+            };
+        }
+    }
+}

src/BuildingRegistry/Building/Building.cs

@@ -206,6 +206,26 @@ public void RemoveConstruction()
             ApplyChange(new BuildingWasRemovedV2(BuildingPersistentLocalId));
         }
 
+        public void RemoveMeasuredBuilding()
+        {
+            if (IsRemoved)
+            {
+                return;
+            }
+
+            if (BuildingGeometry.Method != BuildingGeometryMethod.MeasuredByGrb)
+            {
+                throw new BuildingHasInvalidGeometryMethodException();
+            }
+
+            if(_buildingUnits.GetNotRemovedUnits().Any())
+            {
+                throw new BuildingHasBuildingUnitsException();
+            }
+
+            ApplyChange(new BuildingWasRemovedV2(BuildingPersistentLocalId));
+        }
+
         public void ChangeOutliningConstruction(ExtendedWkbGeometry extendedWkbGeometry)
         {
             GuardRemovedBuilding();

src/BuildingRegistry/Building/BuildingCommandHandlerModule.cs

@@ -169,6 +169,18 @@ public BuildingCommandHandlerModule(
                     building.RemoveConstruction();
                 });
 
+            For<RemoveMeasuredBuilding>()
+                .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer, getSnapshotStore)
+                .AddEventHash<RemoveMeasuredBuilding, Building>(getUnitOfWork)
+                .AddProvenance(getUnitOfWork, provenanceFactory)
+                .Handle(async (message, ct) =>
+                {
+                    var streamId = new BuildingStreamId(message.Command.BuildingPersistentLocalId);
+                    var building = await buildingRepository().GetAsync(streamId, ct);
+
+                    building.RemoveMeasuredBuilding();
+                });
+
             For<ChangeBuildingOutline>()
                 .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer, getSnapshotStore)
                 .AddEventHash<ChangeBuildingOutline, Building>(getUnitOfWork)