FUND-2392 DRC Add resource locking to ensure new versions be created successfully (#151)

* initial commit

* update

* all drc entities uses xmin concurrency token. Made some small fixes

* fixed race condition in old handers. Made other fixes

* fixed UnitTest issue

* cleanup code and made some small fixes

* removed duplicate code

* CancellationToken added for the reat of the controller actions

* co-pilot fixes

* co-pilot fixes

* refactored merge in lockable handlers

* cleanup

* Fixed UnitTest

* comment fixed

* formatted?

* fixed possible race-condition in verzending and gebruiksrecht

* 409 Conflict documented for verzending and gebruiksrecht

Author: heuvea

src/OneGround.ZGW.Common.Contracts/v1/ErrorCode.cs

@@ -64,6 +64,6 @@ public static class ErrorCode
     public const string SelfForbidden = "self-forbidden";
     public const string AmbiguousCatalogi = "ambiguous-catalogi";
     public const string FileSize = "file-size";
-
-    public const string Other = "other"; // TODO: In some cases I don't know the exact code to use. Where can we find them?
+    public const string Conflict = "conflict";
+    public const string Other = "other";
 }

src/OneGround.ZGW.Common.Web/Controllers/ZGWControllerBase.cs

@@ -96,4 +96,14 @@ protected void LogInvalidTaalCode(string taalRequested, string taalMapped)
             );
         }
     }
+
+    protected static T GetValueFromPartial<T>(dynamic jsonObject, string name, bool caseSensitive = false)
+    {
+        var value = jsonObject.Property(name, caseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase)?.Value;
+
+        if (value == null)
+            return default;
+
+        return value.ToObject<T>();
+    }
 }

src/OneGround.ZGW.Common.Web/Extensions/ServiceCollection/ZGWApiServiceCollectionExtensions.cs

@@ -13,8 +13,6 @@
 using OneGround.ZGW.Common.Web.ErrorHandling;
 using OneGround.ZGW.Common.Web.Extensions.ServiceCollection.ZGWApiExtensions;
 using OneGround.ZGW.Common.Web.Filters;
-using OneGround.ZGW.Common.Web.HealthChecks;
-using OneGround.ZGW.Common.Web.HealthChecks.Builder;
 using OneGround.ZGW.Common.Web.Middleware;
 using OneGround.ZGW.Common.Web.Validations;
 using OneGround.ZGW.Common.Web.Versioning;

src/OneGround.ZGW.Common.Web/Filters/ApiExceptionFilter.cs

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.EntityFrameworkCore;
 using OneGround.ZGW.Common.Exceptions;
 using OneGround.ZGW.Common.Web.Services;
 
@@ -28,7 +29,11 @@ public override void OnException(ExceptionContext context)
             context.Result = _responseBuilder.BadRequest(context.ModelState);
             context.ExceptionHandled = true;
         }
-
+        else if (context.Exception is DbUpdateConcurrencyException)
+        {
+            context.Result = _responseBuilder.Conflict();
+            context.ExceptionHandled = true;
+        }
         base.OnException(context);
     }
 }

src/OneGround.ZGW.Common.Web/Services/ErrorResponseBuilder.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using System.Net;
 using FluentValidation.Results;
@@ -267,6 +267,43 @@ public JsonResult InternalServerError(string message)
         };
     }
 
+    public JsonResult Conflict()
+    {
+        var statusCode = (int)HttpStatusCode.Conflict;
+
+        return new JsonResult(
+            new ErrorResponse
+            {
+                Type = $"{BaseUrl}{ErrorCategory.ValidationError}",
+                Code = ErrorCode.Conflict,
+                Title = "Resource is vergrendeld.",
+                Status = statusCode,
+            }
+        )
+        {
+            StatusCode = statusCode,
+        };
+    }
+
+    public JsonResult Conflict(IEnumerable<ValidationError> validationErrors)
+    {
+        var statusCode = (int)HttpStatusCode.Conflict;
+
+        return new JsonResult(
+            new ErrorResponse
+            {
+                Type = $"{BaseUrl}{ErrorCategory.ValidationError}",
+                Code = ErrorCode.Conflict,
+                Title = "Resource is vergrendeld.",
+                Status = statusCode,
+                InvalidParams = validationErrors.ToList(),
+            }
+        )
+        {
+            StatusCode = statusCode,
+        };
+    }
+
     private static ValidationError MapValidationError(ValidationFailure error)
     {
         return new ValidationError(error.PropertyName, MapErrorCode(error), MapErrorMessage(error));

src/OneGround.ZGW.Common.Web/Services/IErrorResponseBuilder.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using FluentValidation.Results;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
@@ -96,4 +96,8 @@ BadRequestObjectResult BadRequest(
     /// <param name="message"></param>
     /// <returns></returns>
     JsonResult InternalServerError(string message = "");
+
+    JsonResult Conflict();
+
+    JsonResult Conflict(IEnumerable<ValidationError> validationErrors);
 }

src/OneGround.ZGW.Common.Web/Validations/ValidationResultExtensions.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Linq;
+using FluentValidation.Results;
+using OneGround.ZGW.Common.Contracts.v1;
+
+namespace OneGround.ZGW.Common.Web.Validations;
+
+public static class ValidationResultExtensions
+{
+    public static List<ValidationError> ToValidationErrors(this ValidationResult validationResult)
+    {
+        return validationResult
+            .Errors.Select(e => new ValidationError
+            {
+                Name = e.PropertyName,
+                Code = e.ErrorCode,
+                Reason = e.ErrorMessage,
+            })
+            .ToList();
+    }
+}

src/OneGround.ZGW.Common/Handlers/CommandStatus.cs

@@ -1,4 +1,4 @@
-namespace OneGround.ZGW.Common.Handlers;
+namespace OneGround.ZGW.Common.Handlers;
 
 public enum CommandStatus
 {
@@ -8,4 +8,5 @@ public enum CommandStatus
     NotFound = HanderStatusCodes.NotFound,
     Forbidden = HanderStatusCodes.Forbidden,
     Failed = HanderStatusCodes.Failed,
+    Conflict = HanderStatusCodes.Conflict,
 }

src/OneGround.ZGW.Common/Handlers/HanderStatusCodes.cs

@@ -1,4 +1,4 @@
-namespace OneGround.ZGW.Common.Handlers;
+namespace OneGround.ZGW.Common.Handlers;
 
 public static class HanderStatusCodes
 {
@@ -8,4 +8,5 @@ public static class HanderStatusCodes
     public const int NotFound = 3;
     public const int Failed = 4;
     public const int Forbidden = 5;
+    public const int Conflict = 6;
 }

src/OneGround.ZGW.DataAccess/EfPostgresLockExtensions.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+
+namespace OneGround.ZGW.DataAccess;
+
+public static class EfPostgresLockExtensions
+{
+    /// <summary>
+    /// Applies PostgreSQL row-level locking (FOR UPDATE [SKIP LOCKED]) to prevent concurrent modifications.
+    /// This locks the rows matching the specified IDs for the duration of the transaction.
+    /// </summary>
+    /// <typeparam name="TEntity">The entity type being queried</typeparam>
+    /// <typeparam name="TKey">The type of the primary key</typeparam>
+    /// <param name="set">The DbSet to query</param>
+    /// <param name="context">The database context</param>
+    /// <param name="keySelector">Expression to select the primary key property</param>
+    /// <param name="ids">The IDs of rows to lock</param>
+    /// <param name="skipLocked">If true, skips locked rows instead of waiting</param>
+    /// <returns>A query with row-level locking applied</returns>
+    public static IQueryable<TEntity> LockForUpdate<TEntity, TKey>(
+        this DbSet<TEntity> set,
+        DbContext context,
+        Expression<Func<TEntity, TKey>> keySelector,
+        IEnumerable<TKey> ids,
+        bool skipLocked = true
+    )
+        where TEntity : class
+    {
+        // Note: The following check fixes the issue when the method LockForUpdate() is called from a UnitTest:
+        //   System.InvalidOperationException : Query root of type 'FromSqlQueryRootExpression' wasn't handled by provider code.
+        //   This issue happens when using a provider specific method on a different provider where it is not supported.
+        if (context.IsInMemory())
+        {
+            // Simply return the set without applying any locking, as InMemory provider does not support raw SQL or locking semantics.
+            return set;
+        }
+
+        var entityType = context.Model.FindEntityType(typeof(TEntity));
+        if (entityType == null)
+        {
+            throw new InvalidOperationException($"Entity type '{typeof(TEntity).Name}' was not found in the database model.");
+        }
+
+        var tableName = entityType.GetTableName();
+        if (string.IsNullOrEmpty(tableName))
+        {
+            throw new InvalidOperationException($"Table name for entity type '{typeof(TEntity).Name}' could not be determined.");
+        }
+
+        var schema = entityType.GetSchema() ?? "public";
+
+        // Safely extract the property name from the key selector expression
+        var propertyName = GetPropertyName(keySelector);
+
+        var property = entityType.FindProperty(propertyName);
+        if (property == null)
+        {
+            throw new InvalidOperationException(
+                $"Property '{propertyName}' was not found on entity type '{typeof(TEntity).Name}'. "
+                    + $"Ensure the key selector expression references a valid property."
+            );
+        }
+
+        var keyColumn = property.GetColumnName();
+        if (string.IsNullOrEmpty(keyColumn))
+        {
+            throw new InvalidOperationException(
+                $"Column name for property '{propertyName}' on entity type '{typeof(TEntity).Name}' could not be determined."
+            );
+        }
+
+        var skip = skipLocked ? " SKIP LOCKED" : "";
+
+        // Include xmin for concurrency token support
+        // Use PostgreSQL's ANY array syntax for efficient parameter passing
+        var sql =
+            $@"
+            SELECT *, xmin
+            FROM ""{schema}"".""{tableName}""
+            WHERE ""{keyColumn}"" = ANY(@ids)
+            ORDER BY ""{keyColumn}""
+            FOR UPDATE{skip}";
+
+        return set.FromSqlRaw(sql, new NpgsqlParameter("ids", ids.ToArray()));
+    }
+
+    /// <summary>
+    /// Extracts the property name from a lambda expression, handling UnaryExpression (conversions/boxing).
+    /// </summary>
+    /// <typeparam name="TEntity">The entity type</typeparam>
+    /// <typeparam name="TKey">The property type</typeparam>
+    /// <param name="expression">The lambda expression selecting the property</param>
+    /// <returns>The property name</returns>
+    /// <exception cref="ArgumentException">Thrown when the expression is not a valid property selector</exception>
+    private static string GetPropertyName<TEntity, TKey>(Expression<Func<TEntity, TKey>> expression)
+    {
+        if (expression == null)
+        {
+            throw new ArgumentNullException(nameof(expression), "Key selector expression cannot be null.");
+        }
+
+        // Unwrap the lambda body
+        Expression body = expression.Body;
+
+        // Handle UnaryExpression (e.g., boxing, implicit conversions like int to object)
+        if (body is UnaryExpression unaryExpression)
+        {
+            body = unaryExpression.Operand;
+        }
+
+        // The body should now be a MemberExpression
+        if (body is MemberExpression memberExpression)
+        {
+            return memberExpression.Member.Name;
+        }
+
+        // If we still don't have a MemberExpression, the selector is invalid
+        throw new ArgumentException(
+            $"Key selector expression must be a simple property accessor (e.g., 'x => x.Id'). "
+                + $"Received expression type: {expression.Body.GetType().Name}",
+            nameof(expression)
+        );
+    }
+
+    /// <summary>
+    /// Determines if the DbContext is using the InMemory provider, which does not support raw SQL or locking semantics.
+    /// </summary>
+    /// <param name="context">The database context</param>
+    /// <returns>True if running within in-memory context (UnitTest), fFalse oterwise</returns>
+    private static bool IsInMemory(this DbContext context)
+    {
+        return context.Database.ProviderName == "Microsoft.EntityFrameworkCore.InMemory";
+    }
+}