fix(work-orders): make stacked tip build for CI quality gates

Api.SeaHavenIndustries.Tests/WorkOrderControllerSearchTests.cs

@@ -59,7 +59,11 @@ public class WorkOrderControllerSearchTests
             Mock.Of<IWorkOrderBoardUpdateService>(),
             Mock.Of<IWorkOrderBoardCreateService>(),
             Mock.Of<IWorkOrderBoardCancelService>(),
-            advancedSearch);
+            advancedSearch,
+            Mock.Of<IWorkOrderDetailService>(),
+            Mock.Of<IWorkOrderCommentService>(),
+            Mock.Of<IWorkOrderCompletionService>(),
+            Mock.Of<IWorkOrderMediaService>());
 
         controller.ControllerContext = new ControllerContext
         {

SeaHaven.DataServices/Implementation/UserDataService.cs

@@ -33,5 +33,27 @@ namespace SeaHaven.DataServices.Implementation
         {
             return await _context.Users.AnyAsync(u => u.Id == id);
         }
+
+        public async Task<IReadOnlyDictionary<string, string>> GetDisplayNamesByIdsAsync(IEnumerable<string> ids)
+        {
+            var idList = ids
+                .Where(id => !string.IsNullOrWhiteSpace(id))
+                .Distinct(StringComparer.Ordinal)
+                .ToList();
+
+            if (idList.Count == 0)
+                return new Dictionary<string, string>(StringComparer.Ordinal);
+
+            var users = await _context.Users
+                .AsNoTracking()
+                .Where(u => idList.Contains(u.Id))
+                .Select(u => new { u.Id, u.FirstName, u.LastName })
+                .ToListAsync();
+
+            return users.ToDictionary(
+                u => u.Id,
+                u => $"{u.FirstName ?? ""} {u.LastName ?? ""}".Trim(),
+                StringComparer.Ordinal);
+        }
     }
 }

SeaHaven.DataServices/Interfaces/IUserDataService.cs

@@ -8,5 +8,6 @@ namespace SeaHaven.DataServices.Interfaces
         Task<IEnumerable<ApplicationUser>> GetAllAsync();
         Task<ApplicationUser?> GetByEmailAsync(string email);
         Task<bool> ExistsAsync(string id);
+        Task<IReadOnlyDictionary<string, string>> GetDisplayNamesByIdsAsync(IEnumerable<string> ids);
     }
 }

SeaHaven.Services/Helpers/WorkOrderAuditProjection.cs

@@ -5,23 +5,69 @@ namespace SeaHaven.Services.Helpers
 {
     public static class WorkOrderAuditProjection
     {
-        public static WorkOrderAuditEntryDto ToDto(WorkOrderAuditLog log)
+        private const string UnassignedLabel = "Unassigned";
+
+        public static WorkOrderAuditEntryDto ToDto(
+            WorkOrderAuditLog log,
+            IReadOnlyDictionary<string, string>? assignToDisplayNames = null)
         {
+            var oldValue = log.OldValue ?? "";
+            var newValue = log.NewValue ?? "";
+
+            if (IsAssignToField(log.FieldName))
+            {
+                oldValue = ResolveAssignToDisplay(oldValue, assignToDisplayNames);
+                newValue = ResolveAssignToDisplay(newValue, assignToDisplayNames);
+            }
+
             return new WorkOrderAuditEntryDto
             {
                 Type = MapEventType(log.EventType),
                 DispatcherId = log.UserId,
                 Action = log.Action ?? "",
                 FieldName = log.FieldName,
-                OldValue = log.OldValue ?? "",
-                NewValue = log.NewValue ?? "",
+                OldValue = oldValue,
+                NewValue = newValue,
                 Time = log.CreatedAt.ToString("o"),
                 DispatchId = log.DispatchId
             };
         }
 
-        public static List<WorkOrderAuditEntryDto> ToDtos(IEnumerable<WorkOrderAuditLog> logs)
-            => logs.Select(ToDto).ToList();
+        public static List<WorkOrderAuditEntryDto> ToDtos(
+            IEnumerable<WorkOrderAuditLog> logs,
+            IReadOnlyDictionary<string, string>? assignToDisplayNames = null)
+            => logs.Select(log => ToDto(log, assignToDisplayNames)).ToList();
+
+        public static IEnumerable<string> CollectAssignToUserIds(IEnumerable<WorkOrderAuditLog> logs)
+        {
+            return logs
+                .Where(l => IsAssignToField(l.FieldName))
+                .SelectMany(l => new[] { l.OldValue, l.NewValue })
+                .Where(v => !string.IsNullOrWhiteSpace(v))
+                .Select(v => v!)
+                .Distinct(StringComparer.Ordinal);
+        }
+
+        internal static bool IsAssignToField(string? fieldName)
+            => string.Equals(fieldName, "AssignTo", StringComparison.OrdinalIgnoreCase)
+               || string.Equals(fieldName, "AssignedTo", StringComparison.OrdinalIgnoreCase);
+
+        private static string ResolveAssignToDisplay(
+            string value,
+            IReadOnlyDictionary<string, string>? assignToDisplayNames)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                return UnassignedLabel;
+
+            if (assignToDisplayNames != null
+                && assignToDisplayNames.TryGetValue(value, out var name)
+                && !string.IsNullOrWhiteSpace(name))
+            {
+                return name;
+            }
+
+            return value;
+        }
 
         private static string MapEventType(string? eventType)
         {

SeaHaven.Services/Helpers/WorkOrderCommentProjection.cs

@@ -5,19 +5,48 @@ namespace SeaHaven.Services.Helpers
 {
     public static class WorkOrderCommentProjection
     {
-        public static WorkOrderCommentDto ToDto(Comments comment)
+        public static WorkOrderCommentDto ToDto(
+            Comments comment,
+            IReadOnlyDictionary<string, string>? displayNames = null)
         {
             return new WorkOrderCommentDto
             {
                 Id = comment.Id,
                 AuthorId = comment.UserId,
+                AuthorName = ResolveAuthorName(comment, displayNames),
                 Text = comment.Commenttext ?? "",
                 Time = (comment.CreatedDate ?? DateTime.UtcNow).ToUniversalTime().ToString("o"),
                 Documents = comment.Documents
             };
         }
 
-        public static List<WorkOrderCommentDto> ToDtos(IEnumerable<Comments> comments)
-            => comments.Select(ToDto).ToList();
+        public static List<WorkOrderCommentDto> ToDtos(
+            IEnumerable<Comments> comments,
+            IReadOnlyDictionary<string, string>? displayNames = null)
+            => comments.Select(c => ToDto(c, displayNames)).ToList();
+
+        public static IEnumerable<string> CollectAuthorUserIds(IEnumerable<Comments> comments)
+            => comments
+                .Where(c => !string.IsNullOrWhiteSpace(c.UserId))
+                .Select(c => c.UserId!)
+                .Distinct(StringComparer.Ordinal);
+
+        private static string? ResolveAuthorName(
+            Comments comment,
+            IReadOnlyDictionary<string, string>? displayNames)
+        {
+            if (!string.IsNullOrWhiteSpace(comment.UserId)
+                && displayNames != null
+                && displayNames.TryGetValue(comment.UserId, out var name)
+                && !string.IsNullOrWhiteSpace(name))
+            {
+                return name;
+            }
+
+            if (!string.IsNullOrWhiteSpace(comment.Commenter))
+                return comment.Commenter.Trim();
+
+            return null;
+        }
     }
 }

SeaHaven.Services/Helpers/WorkOrderFlagColors.cs

@@ -0,0 +1,50 @@
+namespace SeaHaven.Services.Helpers
+{
+    /// <summary>
+    /// Fixed board flag palette (must match FE FLAG_COLORS). Values stored as canonical #RRGGBB.
+    /// </summary>
+    public static class WorkOrderFlagColors
+    {
+        public static readonly HashSet<string> Allowed = new(StringComparer.OrdinalIgnoreCase)
+        {
+            "#EF4444",
+            "#F97316",
+            "#F59E0B",
+            "#EAB308",
+            "#22C55E",
+            "#14B8A6",
+            "#3B82F6",
+            "#8B5CF6"
+        };
+
+        /// <summary>
+        /// Normalizes to # + 6 uppercase hex digits, or null if empty.
+        /// Returns false if the value is non-empty but not a valid hex color.
+        /// </summary>
+        public static bool TryNormalize(string? value, out string? canonical)
+        {
+            canonical = null;
+            if (string.IsNullOrWhiteSpace(value))
+                return true;
+
+            var trimmed = value.Trim();
+            if (trimmed.Length == 6 && trimmed[0] != '#')
+                trimmed = "#" + trimmed;
+
+            if (trimmed.Length != 7 || trimmed[0] != '#')
+                return false;
+
+            for (var i = 1; i < 7; i++)
+            {
+                if (!Char.IsAsciiHexDigit(trimmed[i]))
+                    return false;
+            }
+
+            canonical = "#" + trimmed[1..].ToUpperInvariant();
+            return true;
+        }
+
+        public static bool IsAllowed(string? canonical)
+            => canonical != null && Allowed.Contains(canonical);
+    }
+}