many fixes and improvements - rework for modules/ and common/

feat(emailer): add Postmark and Resend providers

backend/Modules/Messaging/Handlers/AddMessage.cs

@@ -0,0 +1,55 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Messaging.Data;
+
+namespace Hutopy.Modules.Messaging.Handlers;
+
+[PublicAPI]
+public sealed class AddMessageRequest
+{
+    public Guid? Id { get; set; }
+    public required Guid SubjectId { get; set; }
+    public required string Message { get; set; }
+}
+
+internal sealed class AddMessageRequestValidator
+    : Validator<AddMessageRequest>
+{
+    public AddMessageRequestValidator()
+    {
+        RuleFor(r => r.SubjectId)
+            .NotNull().WithMessage("You must specify a SubjectId")
+            .NotEmpty().WithMessage("You must specify a non-empty SubjectId");
+
+        RuleFor(r => r.Message)
+            .NotNull().WithMessage("You must specify a Message")
+            .NotEmpty().WithMessage("You must specify a non-empty Message");
+    }
+}
+
+public class AddMessage(
+    MessagingDbContext context)
+    : Endpoint<AddMessageRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/messages");
+        Options(o => o.WithTags("Messages"));
+    }
+
+    public override async Task HandleAsync(
+        AddMessageRequest req,
+        CancellationToken ct)
+    {
+        var message = new Message
+        {
+            Id = req.Id ?? Guid.CreateVersion7(),
+            SubjectId = req.SubjectId,
+            CreatedBy = User.GetUserId(),
+            Value = req.Message
+        }; 
+        
+        await context.Messages.AddAsync(message, ct);
+
+        await context.SaveChangesAsync(ct);
+    }
+}

backend/Modules/Messaging/Handlers/AddReply.cs

@@ -0,0 +1,61 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Messaging.Data;
+
+namespace Hutopy.Modules.Messaging.Handlers;
+
+[PublicAPI]
+public sealed class AddReplyRequest
+{
+    public Guid? Id { get; set; }
+    public required Guid ParentId { get; set; }
+    public required Guid SubjectId { get; set; }
+    public required string Message { get; set; }
+}
+
+internal sealed class AddReplyRequestValidator
+    : Validator<AddReplyRequest>
+{
+    public AddReplyRequestValidator()
+    {
+        RuleFor(r => r.ParentId)
+            .NotNull().WithMessage("You must specify a ParentId")
+            .NotEmpty().WithMessage("You must specify a non-empty ParentId");
+        
+        RuleFor(r => r.SubjectId)
+            .NotNull().WithMessage("You must specify a SubjectId")
+            .NotEmpty().WithMessage("You must specify a non-empty SubjectId");
+
+        RuleFor(r => r.Message)
+            .NotNull().WithMessage("You must specify a Message")
+            .NotEmpty().WithMessage("You must specify a non-empty Message");
+    }
+}
+
+internal sealed class AddReply(
+    MessagingDbContext context)
+    : Endpoint<AddReplyRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/messages/{ParentId:guid}/replies");
+        Options(o => o.WithTags("Messages"));
+    }
+
+    public override async Task HandleAsync(
+        AddReplyRequest req,
+        CancellationToken ct)
+    {
+        var message = new Message
+        {
+            Id = Guid.CreateVersion7(),
+            SubjectId = req.SubjectId, 
+            ParentId = req.ParentId,
+            CreatedBy = User.GetUserId(),
+            Value = req.Message
+        };
+
+        await context.Messages.AddAsync(message, ct);
+
+        await context.SaveChangesAsync(ct);
+    }
+}

backend/Modules/Messaging/Handlers/ChangeMessage.cs

@@ -0,0 +1,64 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Messaging.Data;
+
+namespace Hutopy.Modules.Messaging.Handlers;
+
+public sealed class ChangeMessageRequest
+{
+    public Guid? Id { get; set; }
+    public required Guid SubjectId { get; set; }
+    public required string Message { get; set; }
+}
+
+internal sealed class ChangeMessageRequestValidator
+    : Validator<ChangeMessageRequest>
+{
+    public ChangeMessageRequestValidator()
+    {
+        RuleFor(r => r.SubjectId)
+            .NotNull().WithMessage("You must specify a SubjectId")
+            .NotEmpty().WithMessage("You must specify a non-empty SubjectId");
+
+        RuleFor(r => r.Message)
+            .NotNull().WithMessage("You must specify a Message")
+            .NotEmpty().WithMessage("You must specify a non-empty Message");
+    }
+}
+
+public class ChangeMessage(
+    MessagingDbContext context)
+    : Endpoint<ChangeMessageRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/messages/update");
+        Options(o => o.WithTags("Messages"));
+    }
+
+    public override async Task HandleAsync(
+        ChangeMessageRequest req,
+        CancellationToken ct)
+    {
+        var message = await context.Messages.FirstOrDefaultAsync(x => x.Id == req.Id, ct);
+        
+        if (message is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+        
+        var userId = HttpContext.User.GetUserId();
+        if (message.CreatedBy != userId)
+        {
+            await SendForbiddenAsync(ct);
+            return;
+        }
+
+        message.SubjectId = req.SubjectId;
+        message.Value = req.Message;
+
+        context.Update(message);
+        
+        await context.SaveChangesAsync(ct);
+    }
+}

backend/Modules/Messaging/Handlers/DeleteMessage.cs

@@ -0,0 +1,52 @@
+using Hutopy.Infrastructure.Security;
+using Hutopy.Modules.Messaging.Data;
+
+namespace Hutopy.Modules.Messaging.Handlers;
+
+public record DeleteMessageRequest(Guid MessageId);
+
+internal sealed class DeleteMessageRequestValidator
+    : Validator<DeleteMessageRequest>
+{
+    public DeleteMessageRequestValidator()
+    {
+        RuleFor(r => r.MessageId)
+            .NotNull().WithMessage("You must specify a MessageId")
+            .NotEmpty().WithMessage("You must specify a non-empty MessageId");
+    }
+}
+
+public class DeleteMessage(
+    MessagingDbContext context)
+    : Endpoint<DeleteMessageRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/messages/{MessageId}");
+        Options(o => o.WithTags("Messages"));
+    }
+
+    public override async Task HandleAsync(
+        DeleteMessageRequest req,
+        CancellationToken ct)
+    {
+        var message = await context.Messages.FirstOrDefaultAsync(x => x.Id == req.MessageId, ct);
+
+        if (message is null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+        
+        var userId = HttpContext.User.GetUserId();
+        if (message.CreatedBy != userId)
+        {
+            await SendForbiddenAsync(ct);
+            return;
+        }
+        
+        context.Messages.Remove(message);
+
+        await context.SaveChangesAsync(ct);
+    }
+}

backend/Modules/Messaging/Handlers/GetMessageCount.cs

@@ -0,0 +1,44 @@
+using Hutopy.Modules.Messaging.Data;
+
+namespace Hutopy.Modules.Messaging.Handlers;
+
+public sealed class GetMessageCountRequest
+{
+    public Guid SubjectId { get; set; }
+    [BindFrom("page_size")] public int PageSize { get; set; } = 1000;
+}
+
+public record struct GetMessageCountResponse
+{
+    public required int Count { get; init; }
+}
+
+public class GetMessageCount(
+    MessagingDbContext context)
+    : Endpoint<GetMessageCountRequest, GetMessageCountResponse>
+{
+    public override void Configure()
+    {
+        Get("/api/messages/{SubjectId:guid}/count");
+        Options(o => o.WithTags("Messages"));
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(
+        GetMessageCountRequest req,
+        CancellationToken ct)
+    {
+        var messageCount = await context.GetMessageCountAsync(
+            req.SubjectId,
+            null,
+            req.PageSize,
+            ct);
+        
+        await SendAsync(
+            new()
+            {
+                Count = messageCount
+            },
+            cancellation: ct);
+    }
+}

backend/Modules/Messaging/Handlers/GetMessages.cs

@@ -0,0 +1,42 @@
+using Hutopy.Modules.Messaging.Data;
+using Hutopy.Modules.Messaging.Models;
+
+namespace Hutopy.Modules.Messaging.Handlers;
+
+[PublicAPI]
+public sealed class GetMessagesRequest
+{
+    public Guid SubjectId { get; set; }
+    [BindFrom("page_size")] public int PageSize { get; set; } = 10;
+    [BindFrom("last_id")] public Guid? LastId { get; set; }
+}
+
+[PublicAPI]
+public record struct GetMessagesResponse(
+    IEnumerable<MessageDto> Messages);
+
+public class GetMessages(
+    MessagingDbContext context)
+    : Endpoint<GetMessagesRequest, GetMessagesResponse>
+{
+    public override void Configure()
+    {
+        Get("/api/messages/{SubjectId:guid}");
+        Options(o => o.WithTags("Messages"));
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(
+        GetMessagesRequest req,
+        CancellationToken ct)
+    {
+        var messages = await context.GetMessagesAsync(
+            req.SubjectId,
+            null,
+            req.LastId,
+            req.PageSize,
+            ct);
+        
+        await SendOkAsync(new GetMessagesResponse(messages), ct);
+    }
+}

backend/Modules/Messaging/Handlers/GetMessagesByUser.cs

@@ -0,0 +1,59 @@
+using Hutopy.Modules.Identity.Contracts;
+using Hutopy.Modules.Messaging.Data;
+using Hutopy.Modules.Messaging.Models;
+
+namespace Hutopy.Modules.Messaging.Handlers;
+
+[PublicAPI]
+public class GetMessagesByUserRequest
+{
+    public Guid UserId { get; set; }
+}
+
+[PublicAPI]
+public record struct GetMessagesByUserResponse(
+    IEnumerable<MessageDto> Messages);
+
+public class GetMessagesByUser(
+    IUserLookup userLookup,
+    MessagingDbContext context)
+    : Endpoint<GetMessagesByUserRequest, GetMessagesByUserResponse>
+{
+    public override void Configure()
+    {
+        Get("/api/messages/user/{UserId:guid}");
+        Options(o => o.WithTags("Messages"));
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(
+        GetMessagesByUserRequest req,
+        CancellationToken ct)
+    {
+        var messages = await context
+            .Messages
+            .Where(c => c.CreatedBy == req.UserId)
+            .Where(c => c.ParentId == null)
+            .ToListAsync(cancellationToken: ct);
+
+        var result = await Task.WhenAll(
+            messages.Select(async message =>
+            {
+                var user = await userLookup.GetUserAsync(message.CreatedBy, ct);
+
+                return new MessageDto
+                {
+                    Id = message.Id,
+                    ParentId = message.ParentId,
+                    CreatedAt = message.CreatedAt,
+                    CreatedBy = message.CreatedBy,
+                    CreatedByName = user?.Fullname ?? "Unknown User",
+                    CreatedByPortraitUrl = user?.PortraitUrl ?? "",
+                    SubjectId = message.SubjectId,
+                    Value = message.Value
+                };
+            }));
+
+        await SendOkAsync(new GetMessagesByUserResponse(result), ct);
+    }
+}

backend/Modules/Messaging/Handlers/GetReplies.cs

@@ -0,0 +1,43 @@
+using Hutopy.Modules.Messaging.Data;
+using Hutopy.Modules.Messaging.Models;
+
+namespace Hutopy.Modules.Messaging.Handlers;
+
+[PublicAPI]
+public class GetRepliesRequest
+{
+    public Guid SubjectId { get; set; }
+    public Guid ParentId { get; set; }
+    [BindFrom("page_size")] public int PageSize { get; set; } = 10;
+    [BindFrom("last_id")] public Guid? LastId { get; set; }
+}
+
+[PublicAPI]
+public record struct GetRepliesResponse(
+    IEnumerable<MessageDto> Messages);
+
+public class GetReplies(
+    MessagingDbContext context)
+    : Endpoint<GetRepliesRequest, GetRepliesResponse>
+{
+    public override void Configure()
+    {
+        Get("/api/messages/{ParentId:guid}/replies");
+        Options(o => o.WithTags("Messages"));
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(
+        GetRepliesRequest req,
+        CancellationToken ct)
+    {
+        var replies = await context.GetMessagesAsync(
+            req.SubjectId,
+            req.ParentId,
+            req.LastId,
+            req.PageSize,
+            ct);
+
+        await SendOkAsync(new GetRepliesResponse(replies), ct);
+    }
+}