feat: add notification bell, preferences page, and admin management

Phase 2 of the notifications system:

- Notification bell in top navbar with unread count badge and dropdown
  - AJAX polling every 60s for unread count
  - Load recent notifications on dropdown open
  - Mark as read (individual + all) with anti-forgery tokens
- Profile/Notifications self-service preferences page
  - Checkbox matrix: notification types  channels (InSite/Email)
  - Greyed-out unsupported channels, opt-in defaults
- Profile/AllNotifications full paginated notifications list
- Admin User management: ManageNotifications page
  - View any user's notification history
  - Edit any user's notification preferences
- NotificationsApiController for bell AJAX endpoints
- Updated NuGet: XtremeIdiots.Portal.Repository.Api.Client.V1  2.1.165

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: frasermolyneux

src/XtremeIdiots.Portal.Integrations.Forums/XtremeIdiots.Portal.Integrations.Forums.csproj

@@ -12,7 +12,7 @@
     <PackageReference Include="Azure.Identity" Version="1.17.1" />
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="10.0.3" />
     <PackageReference Include="MX.InvisionCommunity.Api.Client" Version="1.0.18" />
-    <PackageReference Include="XtremeIdiots.Portal.Repository.Api.Client.V1" Version="2.1.135" />
+    <PackageReference Include="XtremeIdiots.Portal.Repository.Api.Client.V1" Version="2.1.165" />
   </ItemGroup>
 
 </Project>

src/XtremeIdiots.Portal.Web/ApiControllers/NotificationsApiController.cs

@@ -0,0 +1,140 @@
+using Microsoft.ApplicationInsights;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+using XtremeIdiots.Portal.Repository.Abstractions.Constants.V1;
+using XtremeIdiots.Portal.Repository.Api.Client.V1;
+using XtremeIdiots.Portal.Web.Extensions;
+
+namespace XtremeIdiots.Portal.Web.ApiControllers;
+
+/// <summary>
+/// API controller for notification operations (bell dropdown)
+/// </summary>
+[Authorize]
+[Route("api/notifications")]
+public class NotificationsApiController(
+    IRepositoryApiClient repositoryApiClient,
+    TelemetryClient telemetryClient,
+    ILogger<NotificationsApiController> logger,
+    IConfiguration configuration) : BaseApiController(telemetryClient, logger, configuration)
+{
+    /// <summary>
+    /// Gets the unread notification count for the current user
+    /// </summary>
+    [HttpGet("unread-count")]
+    public async Task<IActionResult> GetUnreadCount(CancellationToken cancellationToken = default)
+    {
+        return await ExecuteWithErrorHandlingAsync(async () =>
+        {
+            var userProfileId = User.UserProfileId();
+            if (string.IsNullOrEmpty(userProfileId))
+            {
+                return Ok(new { count = 0 });
+            }
+
+            var response = await repositoryApiClient.Notifications.V1
+                .GetUnreadNotificationCount(Guid.Parse(userProfileId), cancellationToken)
+                .ConfigureAwait(false);
+
+            var count = response.Result?.Data ?? 0;
+
+            return Ok(new { count });
+        }, nameof(GetUnreadCount)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Gets the most recent notifications for the current user
+    /// </summary>
+    /// <param name="take">Number of notifications to return (default 10)</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    [HttpGet("recent")]
+    public async Task<IActionResult> GetRecent([FromQuery] int take = 10, CancellationToken cancellationToken = default)
+    {
+        return await ExecuteWithErrorHandlingAsync(async () =>
+        {
+            var userProfileId = User.UserProfileId();
+            if (string.IsNullOrEmpty(userProfileId))
+            {
+                return Ok(Array.Empty<object>());
+            }
+
+            var response = await repositoryApiClient.Notifications.V1
+                .GetNotifications(Guid.Parse(userProfileId), null, 0, take, NotificationOrder.CreatedAtDesc, cancellationToken)
+                .ConfigureAwait(false);
+
+            if (response.Result?.Data?.Items is null)
+            {
+                return Ok(Array.Empty<object>());
+            }
+
+            var notifications = response.Result.Data.Items.Select(n => new
+            {
+                n.NotificationId,
+                n.Title,
+                n.Message,
+                n.ActionUrl,
+                n.IsRead,
+                n.CreatedAt
+            });
+
+            return Ok(notifications);
+        }, nameof(GetRecent)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Marks a single notification as read
+    /// </summary>
+    /// <param name="id">Notification ID</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    [HttpPost("{id}/read")]
+    [ValidateAntiForgeryToken]
+    public async Task<IActionResult> MarkAsRead(Guid id, CancellationToken cancellationToken = default)
+    {
+        return await ExecuteWithErrorHandlingAsync(async () =>
+        {
+            var userProfileId = User.UserProfileId();
+            if (string.IsNullOrEmpty(userProfileId))
+            {
+                return Unauthorized();
+            }
+
+            await repositoryApiClient.Notifications.V1
+                .MarkNotificationAsRead(id, cancellationToken)
+                .ConfigureAwait(false);
+
+            TrackSuccessTelemetry("NotificationMarkedAsRead", nameof(MarkAsRead), new Dictionary<string, string>
+            {
+                { "NotificationId", id.ToString() }
+            });
+
+            return Ok();
+        }, nameof(MarkAsRead)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Marks all notifications as read for the current user
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token</param>
+    [HttpPost("read-all")]
+    [ValidateAntiForgeryToken]
+    public async Task<IActionResult> MarkAllAsRead(CancellationToken cancellationToken = default)
+    {
+        return await ExecuteWithErrorHandlingAsync(async () =>
+        {
+            var userProfileId = User.UserProfileId();
+            if (string.IsNullOrEmpty(userProfileId))
+            {
+                return Unauthorized();
+            }
+
+            await repositoryApiClient.Notifications.V1
+                .MarkAllNotificationsAsRead(Guid.Parse(userProfileId), cancellationToken)
+                .ConfigureAwait(false);
+
+            TrackSuccessTelemetry("AllNotificationsMarkedAsRead", nameof(MarkAllAsRead));
+
+            return Ok();
+        }, nameof(MarkAllAsRead)).ConfigureAwait(false);
+    }
+}

src/XtremeIdiots.Portal.Web/Controllers/ProfileController.cs

@@ -2,28 +2,31 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
+using XtremeIdiots.Portal.Repository.Abstractions.Models.V1.Notifications;
 using XtremeIdiots.Portal.Repository.Api.Client.V1;
 using XtremeIdiots.Portal.Web.Auth.Constants;
+using XtremeIdiots.Portal.Web.Extensions;
+using XtremeIdiots.Portal.Web.Models;
 
 namespace XtremeIdiots.Portal.Web.Controllers;
 
 /// <summary>
-/// Handles user profile management operations
+/// Handles user profile management operations including notification preferences
 /// </summary>
 /// <remarks>
 /// Initializes a new instance of the ProfileController
 /// </remarks>
+/// <param name="repositoryApiClient">Client for repository API operations</param>
 /// <param name="telemetryClient">Application Insights telemetry client</param>
 /// <param name="logger">Logger instance for this controller</param>
 /// <param name="configuration">Application configuration</param>
 [Authorize(Policy = AuthPolicies.AccessProfile)]
 public class ProfileController(
+    IRepositoryApiClient repositoryApiClient,
     TelemetryClient telemetryClient,
     ILogger<ProfileController> logger,
     IConfiguration configuration) : BaseController(telemetryClient, logger, configuration)
 {
-    // No additional dependencies required for current actions
-
     /// <summary>
     /// Displays the user profile management page
     /// </summary>
@@ -34,4 +37,167 @@ public async Task<IActionResult> Manage(CancellationToken cancellationToken = de
     {
         return await ExecuteWithErrorHandlingAsync(() => Task.FromResult<IActionResult>(View()), nameof(Manage)).ConfigureAwait(false);
     }
+
+    /// <summary>
+    /// Displays the notification preferences page where users can configure delivery channels
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token for the async operation</param>
+    /// <returns>The notification preferences view</returns>
+    [HttpGet]
+    public async Task<IActionResult> Notifications(CancellationToken cancellationToken = default)
+    {
+        return await ExecuteWithErrorHandlingAsync(async () =>
+        {
+            var xtremeIdiotsId = User.XtremeIdiotsId();
+            if (string.IsNullOrEmpty(xtremeIdiotsId))
+                return RedirectToAction(nameof(Manage));
+
+            var userProfileResponse = await repositoryApiClient.UserProfiles.V1
+                .GetUserProfileByXtremeIdiotsId(xtremeIdiotsId).ConfigureAwait(false);
+
+            if (userProfileResponse.IsNotFound || userProfileResponse.Result?.Data is null)
+                return RedirectToAction(nameof(Manage));
+
+            var userProfile = userProfileResponse.Result.Data;
+
+            var typesResponse = await repositoryApiClient.NotificationTypes.V1
+                .GetNotificationTypes(cancellationToken).ConfigureAwait(false);
+
+            var prefsResponse = await repositoryApiClient.NotificationPreferences.V1
+                .GetNotificationPreferences(userProfile.UserProfileId, cancellationToken).ConfigureAwait(false);
+
+            var notificationTypes = (typesResponse.Result?.Data?.Items ?? [])
+                .Select(t => new NotificationTypeViewModel(
+                    t.NotificationTypeId, t.DisplayName, t.Description,
+                    t.SupportsInSite, t.SupportsEmail,
+                    (t.DefaultChannels ?? "").Contains("InSite"),
+                    (t.DefaultChannels ?? "").Contains("Email")))
+                .ToList();
+
+            var preferences = (prefsResponse.Result?.Data?.Items ?? [])
+                .Select(p => new NotificationPreferenceViewModel(
+                    p.NotificationTypeId, p.InSiteEnabled, p.EmailEnabled))
+                .ToList();
+
+            var model = new NotificationPreferencesPageViewModel(
+                userProfile.UserProfileId,
+                notificationTypes,
+                preferences);
+
+            return View(model);
+        }, nameof(Notifications)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Saves notification preferences submitted from the preferences form
+    /// </summary>
+    /// <param name="userProfileId">The user profile ID to save preferences for</param>
+    /// <param name="cancellationToken">Cancellation token for the async operation</param>
+    /// <returns>Redirects back to the notification preferences page</returns>
+    [HttpPost]
+    [ValidateAntiForgeryToken]
+    public async Task<IActionResult> Notifications(Guid userProfileId, CancellationToken cancellationToken = default)
+    {
+        return await ExecuteWithErrorHandlingAsync(async () =>
+        {
+            var form = await Request.ReadFormAsync(cancellationToken).ConfigureAwait(false);
+            var typeIds = form.Keys
+                .Where(k => k.StartsWith("insite_", StringComparison.Ordinal) || k.StartsWith("email_", StringComparison.Ordinal))
+                .Select(k => k.Split('_', 2)[1])
+                .Distinct()
+                .ToList();
+
+            var preferences = new List<NotificationPreferenceViewModel>();
+
+            foreach (var typeId in typeIds)
+            {
+                preferences.Add(new NotificationPreferenceViewModel(
+                    typeId,
+                    InSiteEnabled: form.ContainsKey($"insite_{typeId}"),
+                    EmailEnabled: form.ContainsKey($"email_{typeId}")));
+            }
+
+            // Handle notification types where both checkboxes are unchecked (not present in form)
+            var allTypesResponse = await repositoryApiClient.NotificationTypes.V1
+                .GetNotificationTypes(cancellationToken).ConfigureAwait(false);
+            var allTypeIds = (allTypesResponse.Result?.Data?.Items ?? []).Select(t => t.NotificationTypeId);
+
+            foreach (var typeId in allTypeIds)
+            {
+                if (!typeIds.Contains(typeId))
+                {
+                    preferences.Add(new NotificationPreferenceViewModel(
+                        typeId,
+                        InSiteEnabled: false,
+                        EmailEnabled: false));
+                }
+            }
+
+            var editDtos = preferences.Select(p => new EditNotificationPreferenceDto(p.NotificationTypeId)
+            {
+                InSiteEnabled = p.InSiteEnabled,
+                EmailEnabled = p.EmailEnabled
+            }).ToList();
+
+            await repositoryApiClient.NotificationPreferences.V1
+                .UpdateNotificationPreferences(userProfileId, editDtos, cancellationToken).ConfigureAwait(false);
+
+            this.AddAlertSuccess("Notification preferences saved successfully.");
+            return RedirectToAction(nameof(Notifications));
+        }, nameof(Notifications)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Displays all notifications for the current user with pagination
+    /// </summary>
+    /// <param name="page">Page number (1-based)</param>
+    /// <param name="cancellationToken">Cancellation token for the async operation</param>
+    /// <returns>The all notifications view</returns>
+    [HttpGet]
+    public async Task<IActionResult> AllNotifications(int page = 1, CancellationToken cancellationToken = default)
+    {
+        return await ExecuteWithErrorHandlingAsync(async () =>
+        {
+            var xtremeIdiotsId = User.XtremeIdiotsId();
+            if (string.IsNullOrEmpty(xtremeIdiotsId))
+                return RedirectToAction(nameof(Manage));
+
+            var userProfileResponse = await repositoryApiClient.UserProfiles.V1
+                .GetUserProfileByXtremeIdiotsId(xtremeIdiotsId).ConfigureAwait(false);
+
+            if (userProfileResponse.IsNotFound || userProfileResponse.Result?.Data is null)
+                return RedirectToAction(nameof(Manage));
+
+            const int pageSize = 20;
+            var skipEntries = (Math.Max(1, page) - 1) * pageSize;
+            var userProfileId = userProfileResponse.Result.Data.UserProfileId;
+
+            var notificationsResponse = await repositoryApiClient.Notifications.V1
+                .GetNotifications(userProfileId, null, skipEntries, pageSize, null, cancellationToken).ConfigureAwait(false);
+
+            var unreadCountResponse = await repositoryApiClient.Notifications.V1
+                .GetUnreadNotificationCount(userProfileId, cancellationToken).ConfigureAwait(false);
+
+            var items = notificationsResponse.Result?.Data?.Items ?? [];
+            var totalCount = notificationsResponse.Result?.Pagination?.TotalCount ?? 0;
+            var unreadCount = unreadCountResponse.Result?.Data ?? 0;
+            var totalPages = Math.Max(1, (int)Math.Ceiling((double)totalCount / pageSize));
+
+            var notifications = items.Select(n => new NotificationViewModel(
+                n.NotificationId, n.Title, n.Message,
+                "fa-solid fa-bell",
+                n.CreatedAt, n.IsRead,
+                n.ActionUrl)).ToList();
+
+            var model = new AllNotificationsPageViewModel(
+                notifications,
+                CurrentPage: Math.Max(1, page),
+                TotalPages: totalPages,
+                TotalCount: totalCount,
+                UnreadCount: unreadCount);
+
+            return View(model);
+        }, nameof(AllNotifications)).ConfigureAwait(false);
+    }
+
 }