Feature/notification settings

src/shared/Jordnaer.Shared/Database/Enums/ChatNotificationPreference.cs

@@ -0,0 +1,17 @@
+using System.ComponentModel.DataAnnotations;
+using NetEscapades.EnumGenerators;
+
+namespace Jordnaer.Shared;
+
+[EnumExtensions]
+public enum ChatNotificationPreference
+{
+	[Display(Name = "Ingen")]
+	None = 0,
+
+	[Display(Name = "Kun første besked i ny samtale")]
+	FirstMessageOnly = 1,
+
+	[Display(Name = "Alle beskeder")]
+	AllMessages = 2
+}

src/shared/Jordnaer.Shared/Database/GroupMembership.cs

@@ -20,4 +20,10 @@ public class GroupMembership
 	public MembershipStatus MembershipStatus { get; set; }
 	public PermissionLevel PermissionLevel { get; set; } = PermissionLevel.None;
 	public OwnershipLevel OwnershipLevel { get; set; } = OwnershipLevel.None;
+
+	/// <summary>
+	/// Whether the user wants email notifications for new posts in this group.
+	/// Default is true.
+	/// </summary>
+	public bool EmailOnNewPost { get; set; } = true;
 }

src/shared/Jordnaer.Shared/Database/UserProfile.cs

@@ -54,6 +54,8 @@ public class UserProfile
 	public List<Group> Groups { get; set; } = [];
 	public List<GroupMembership> GroupMemberships { get; set; } = [];
 
+	public ChatNotificationPreference ChatNotificationPreference { get; set; } = ChatNotificationPreference.FirstMessageOnly;
+
 	public DateTime? DateOfBirth { get; set; }
 
 	public string ProfilePictureUrl { get; set; } = ProfileConstants.Default_Profile_Picture;

src/web/Jordnaer/Consumers/GroupPostCreatedConsumer.cs

@@ -1,10 +1,11 @@
 using Jordnaer.Database;
+using Jordnaer.Extensions;
 using Jordnaer.Features.Email;
 using Jordnaer.Features.Metrics;
 using Jordnaer.Shared;
 using MassTransit;
-using Microsoft.AspNetCore.Components;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
 using System.Net;
 using System.Text.RegularExpressions;
 
@@ -14,7 +15,7 @@ public partial class GroupPostCreatedConsumer(
 	IDbContextFactory<JordnaerDbContext> contextFactory,
 	ILogger<GroupPostCreatedConsumer> logger,
 	IPublishEndpoint publishEndpoint,
-	NavigationManager navigationManager) : IConsumer<GroupPostCreated>
+	IOptions<AppOptions> appOptions) : IConsumer<GroupPostCreated>
 {
 	public async Task Consume(ConsumeContext<GroupPostCreated> consumeContext)
 	{
@@ -29,18 +30,20 @@ public async Task Consume(ConsumeContext<GroupPostCreated> consumeContext)
 		{
 			await using var context = await contextFactory.CreateDbContextAsync(consumeContext.CancellationToken);
 
-			// Get all active members excluding the post author
-			var activeMembers = context.GroupMemberships
+			// Get all active members excluding the post author who have email notifications enabled
+			var activeMembers = await context.GroupMemberships
 				.AsNoTracking()
 				.Where(x => x.GroupId == message.GroupId &&
 						   x.MembershipStatus == MembershipStatus.Active &&
-						   x.UserProfileId != message.AuthorId)
-				.Select(x => x.UserProfileId);
+						   x.UserProfileId != message.AuthorId &&
+						   x.EmailOnNewPost)
+				.Select(x => x.UserProfileId)
+				.ToListAsync(consumeContext.CancellationToken);
 
 			// Get their email addresses
 			var emails = await context.Users
 				.AsNoTracking()
-				.Where(user => activeMembers.Any(userId => userId == user.Id) &&
+				.Where(user => activeMembers.Contains(user.Id) &&
 							  !string.IsNullOrEmpty(user.Email))
 				.Select(user => new EmailRecipient
 				{
@@ -59,7 +62,8 @@ public async Task Consume(ConsumeContext<GroupPostCreated> consumeContext)
 			logger.LogInformation("Sending new post notification to {Count} members in group {GroupName}",
 				emails.Count, message.GroupName);
 
-			var groupUrl = $"{navigationManager.BaseUri}groups/{message.GroupName}";
+			var baseUrl = appOptions.Value.BaseUrl.TrimEnd('/');
+			var groupUrl = $"{baseUrl}/groups/{message.GroupName}";
 			var postPreview = GetPostPreview(message.PostText);
 
 			var email = new SendEmail

src/web/Jordnaer/Consumers/SendMessageConsumer.cs

@@ -12,7 +12,8 @@ namespace Jordnaer.Consumers;
 public class SendMessageConsumer(
 	JordnaerDbContext context,
 	ILogger<SendMessageConsumer> logger,
-	IHubContext<ChatHub, IChatHub> chatHub)
+	IHubContext<ChatHub, IChatHub> chatHub,
+	ChatNotificationService chatNotificationService)
 	: IConsumer<SendMessage>
 {
 	public async Task Consume(ConsumeContext<SendMessage> consumeContext)
@@ -65,6 +66,9 @@ await context.Chats
 			throw;
 		}
 
+		// Send email notifications to users who want all messages
+		await chatNotificationService.NotifyRecipientsOfNewMessage(chatMessage, consumeContext.CancellationToken);
+
 		JordnaerMetrics.ChatMessagesSentCounter.Add(1);
 	}
 }

src/web/Jordnaer/Features/Chat/ChatNotificationService.cs

@@ -1,29 +1,44 @@
 using Jordnaer.Consumers;
 using Jordnaer.Database;
+using Jordnaer.Extensions;
 using Jordnaer.Features.Email;
 using Jordnaer.Shared;
 using MassTransit;
-using Microsoft.AspNetCore.Hosting.Server;
-using Microsoft.AspNetCore.Hosting.Server.Features;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
 
 namespace Jordnaer.Features.Chat;
 
 public class ChatNotificationService(
 	IDbContextFactory<JordnaerDbContext> contextFactory,
 	ILogger<StartChatConsumer> logger,
 	IPublishEndpoint publishEndpoint,
-	IServer server) // TODO: Swap with NavigationManager
+	IOptions<AppOptions> options)
 {
 	public async Task NotifyRecipients(StartChat startChat, CancellationToken cancellationToken = default)
 	{
 		await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 		var recipientIds = startChat.Recipients.Select(recipient => recipient.Id);
-		var recipients = await context.Users
-									  .AsNoTracking()
-									  .Where(x => recipientIds.Contains(x.Id) && !string.IsNullOrEmpty(x.Email))
-									  .ToDictionaryAsync(x => x.Id, x => x.Email!, cancellationToken);
 
+		// Get users with email and their notification preferences
+		var usersWithPreferences = await context.Users
+			.AsNoTracking()
+			.Where(x => recipientIds.Contains(x.Id) && !string.IsNullOrEmpty(x.Email))
+			.Join(context.UserProfiles,
+				user => user.Id,
+				profile => profile.Id,
+				(user, profile) => new { user.Id, user.Email, profile.ChatNotificationPreference })
+			.Where(x => x.ChatNotificationPreference == ChatNotificationPreference.FirstMessageOnly
+				|| x.ChatNotificationPreference == ChatNotificationPreference.AllMessages)
+			.ToListAsync(cancellationToken);
+
+		if (!usersWithPreferences.Any())
+		{
+			logger.LogInformation("No recipients want chat notifications for this message.");
+			return;
+		}
+
+		var recipients = usersWithPreferences.ToDictionary(x => x.Id, x => x.Email!);
 		var emailsToSend = CreateEmails(startChat, recipients);
 
 		await publishEndpoint.PublishBatch(emailsToSend, cancellationToken);
@@ -58,25 +73,80 @@ internal IEnumerable<SendEmail> CreateEmails(StartChat startChat, Dictionary<str
 
 	internal string GetChatLink(Guid chatId)
 	{
-		//TODO: Replace address look-up with config
-		var serverAddressFeature = server.Features.Get<IServerAddressesFeature>();
-		var serverAddress = serverAddressFeature?.Addresses.FirstOrDefault();
-
-		if (serverAddress is null)
-		{
-			logger.LogError("No addresses found in the IServerAddressFeature. A link to the chat cannot be created.");
-		}
+		var serverAddress = options.Value.BaseUrl?.TrimEnd('/');
 
 		return serverAddress is null
 				   ? $"https://mini-moeder.dk/chat/{chatId}"
 				   : $"{serverAddress}/chat/{chatId}";
 	}
 
+	public async Task NotifyRecipientsOfNewMessage(SendMessage message, CancellationToken cancellationToken = default)
+	{
+		await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+		// Get all recipients of this chat (excluding the sender)
+		var recipientIds = await context.UserChats
+			.Where(x => x.ChatId == message.ChatId && x.UserProfileId != message.SenderId)
+			.Select(x => x.UserProfileId)
+			.ToListAsync(cancellationToken);
+
+		// Get users who want "AllMessages" notifications
+		var usersWithPreferences = await context.Users
+			.AsNoTracking()
+			.Where(x => recipientIds.Contains(x.Id) && !string.IsNullOrEmpty(x.Email))
+			.Join(context.UserProfiles,
+				user => user.Id,
+				profile => profile.Id,
+				(user, profile) => new { user.Id, user.Email, User = user, profile.ChatNotificationPreference })
+			.Where(x => x.ChatNotificationPreference == ChatNotificationPreference.AllMessages)
+			.ToListAsync(cancellationToken);
+
+		if (!usersWithPreferences.Any())
+		{
+			logger.LogInformation("No recipients want all-message notifications for this chat.");
+			return;
+		}
+
+		// Get sender info
+		var sender = await context.UserProfiles
+			.AsNoTracking()
+			.FirstOrDefaultAsync(x => x.Id == message.SenderId, cancellationToken);
+
+		if (sender is null)
+		{
+			logger.LogWarning("Sender profile not found for message notification.");
+			return;
+		}
+
+		var chatLink = GetChatLink(message.ChatId);
+		var emailsToSend = new List<SendEmail>();
+
+		foreach (var userWithPref in usersWithPreferences)
+		{
+			var recipientEmailAddress = new EmailRecipient
+			{
+				Email = userWithPref.Email!,
+				DisplayName = userWithPref.User.UserName ?? userWithPref.Email!
+			};
+
+			emailsToSend.Add(new SendEmail
+			{
+				To = [recipientEmailAddress],
+				Subject = $"Ny besked fra {sender.DisplayName}",
+				HtmlContent = CreateNewChatEmailMessage(recipientEmailAddress.DisplayName, sender.DisplayName, chatLink)
+			});
+		}
+
+		await publishEndpoint.PublishBatch(emailsToSend, cancellationToken);
+
+		logger.LogInformation("Sent {Count} emails for new chat message.", emailsToSend.Count);
+	}
+
 	private static string CreateNewChatEmailMessage(string recipientDisplayName,
 		string messageSenderDisplayName,
 		string link) => $"""
 						 {EmailConstants.Greeting(recipientDisplayName)}
-						 
+
 						 <p>Du har fået en ny besked fra <b>{messageSenderDisplayName}</b></p>
 
 						 <p>Hvis du vil gå direkte til beskeden, kan du klikke på linket nedenfor:</p>

src/web/Jordnaer/Features/Notifications/NotificationSettingsService.cs

@@ -0,0 +1,87 @@
+using Jordnaer.Database;
+using Jordnaer.Shared;
+using Microsoft.EntityFrameworkCore;
+using OneOf;
+using OneOf.Types;
+
+namespace Jordnaer.Features.Notifications;
+
+public interface INotificationSettingsService
+{
+	Task<ChatNotificationPreference> GetChatPreferenceAsync(string userId, CancellationToken cancellationToken = default);
+	Task<OneOf<Success, NotFound>> SetChatPreferenceAsync(string userId, ChatNotificationPreference preference, CancellationToken cancellationToken = default);
+	Task<OneOf<Success, NotFound>> SetGroupPostPreferenceAsync(string userId, Guid groupId, bool enabled, CancellationToken cancellationToken = default);
+	Task<OneOf<Success, NotFound>> SetAllGroupPostPreferencesAsync(string userId, bool enabled, CancellationToken cancellationToken = default);
+	Task<List<GroupMembership>> GetGroupPreferencesAsync(string userId, CancellationToken cancellationToken = default);
+}
+
+public class NotificationSettingsService(IDbContextFactory<JordnaerDbContext> contextFactory) : INotificationSettingsService
+{
+	public async Task<ChatNotificationPreference> GetChatPreferenceAsync(string userId, CancellationToken cancellationToken = default)
+	{
+		await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+		var userProfile = await context.UserProfiles
+			.AsNoTracking()
+			.FirstOrDefaultAsync(x => x.Id == userId, cancellationToken);
+
+		return userProfile?.ChatNotificationPreference ?? ChatNotificationPreference.FirstMessageOnly;
+	}
+
+	public async Task<OneOf<Success, NotFound>> SetChatPreferenceAsync(string userId, ChatNotificationPreference preference, CancellationToken cancellationToken = default)
+	{
+		await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+		var userProfile = await context.UserProfiles
+			.FirstOrDefaultAsync(x => x.Id == userId, cancellationToken);
+
+		if (userProfile is null)
+		{
+			return new NotFound();
+		}
+
+		userProfile.ChatNotificationPreference = preference;
+		await context.SaveChangesAsync(cancellationToken);
+		return new Success();
+	}
+
+	public async Task<OneOf<Success, NotFound>> SetGroupPostPreferenceAsync(string userId, Guid groupId, bool enabled, CancellationToken cancellationToken = default)
+	{
+		await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+		var membership = await context.GroupMemberships
+			.FirstOrDefaultAsync(x => x.UserProfileId == userId && x.GroupId == groupId, cancellationToken);
+
+		if (membership is null)
+		{
+			return new NotFound();
+		}
+
+		membership.EmailOnNewPost = enabled;
+		await context.SaveChangesAsync(cancellationToken);
+		return new Success();
+	}
+
+	public async Task<OneOf<Success, NotFound>> SetAllGroupPostPreferencesAsync(string userId, bool enabled, CancellationToken cancellationToken = default)
+	{
+		await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+		var rowsAffected = await context.GroupMemberships
+			.Where(x => x.UserProfileId == userId && x.MembershipStatus == MembershipStatus.Active)
+			.ExecuteUpdateAsync(setters => setters.SetProperty(m => m.EmailOnNewPost, enabled), cancellationToken);
+
+		return rowsAffected > 0 ? new Success() : new NotFound();
+	}
+
+	public async Task<List<GroupMembership>> GetGroupPreferencesAsync(string userId, CancellationToken cancellationToken = default)
+	{
+		await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+		// Get all active memberships with group information
+		return await context.GroupMemberships
+			.AsNoTracking()
+			.Where(x => x.UserProfileId == userId && x.MembershipStatus == MembershipStatus.Active)
+			.Include(x => x.Group)
+			.ToListAsync(cancellationToken);
+	}
+}

src/web/Jordnaer/Features/Notifications/WebApplicationBuilderExtensions.cs

@@ -0,0 +1,10 @@
+namespace Jordnaer.Features.Notifications;
+
+public static class WebApplicationBuilderExtensions
+{
+	public static WebApplicationBuilder AddNotificationServices(this WebApplicationBuilder builder)
+	{
+		builder.Services.AddScoped<INotificationSettingsService, NotificationSettingsService>();
+		return builder;
+	}
+}