Implement delete endpoint for Files, Nodes, Notes, Reminders and Timelines module

Backend/src/Modules/Files/Files.Api/Endpoints/Files/DeleteFileAsset.cs

@@ -0,0 +1,25 @@
+using Files.Application.Entities.Files.Commands.DeleteFileAsset;
+
+namespace Files.Api.Endpoints.Files;
+
+public class DeleteFileAsset : ICarterModule
+{
+    public void AddRoutes(IEndpointRouteBuilder app)
+    {
+        app.MapDelete("/Files/{fileId}", async (string fileId, ISender sender) =>
+            {
+                var result = await sender.Send(new DeleteFileAssetCommand(fileId));
+                var response = result.Adapt<DeleteFileAssetResponse>();
+
+                return Results.Ok(response);
+            })
+            .WithName("DeleteFileAsset")
+            .Produces<DeleteFileAssetResponse>()
+            .ProducesProblem(StatusCodes.Status400BadRequest)
+            .ProducesProblem(StatusCodes.Status404NotFound)
+            .WithSummary("Delete File Asset")
+            .WithDescription("Delete File Asset");
+    }
+}
+
+public record DeleteFileAssetResponse(bool FileDeleted);

Backend/src/Modules/Files/Files.Application/Entities/Files/Commands/DeleteFileAsset/DeleteFileAssetCommand.cs

@@ -0,0 +1,13 @@
+namespace Files.Application.Entities.Files.Commands.DeleteFileAsset;
+
+public record DeleteFileAssetCommand(string FileAssetId) : ICommand<DeleteFileAssetResult>;
+
+public record DeleteFileAssetResult(bool FileDeleted);
+
+public class DeleteFileAssetCommandValidator : AbstractValidator<DeleteFileAssetCommand>
+{
+    public DeleteFileAssetCommandValidator()
+    {
+        RuleFor(x => x.FileAssetId).NotEmpty().WithMessage("FileAssetId is required");
+    }
+}

Backend/src/Modules/Files/Files.Application/Entities/Files/Commands/DeleteFileAsset/DeleteFileAssetHandler.cs

@@ -0,0 +1,22 @@
+using Files.Application.Entities.Files.Exceptions;
+
+namespace Files.Application.Entities.Files.Commands.DeleteFileAsset;
+
+public class DeleteFileAssetHandler(IFilesDbContext dbContext) : ICommandHandler<DeleteFileAssetCommand, DeleteFileAssetResult>
+{
+    public async Task<DeleteFileAssetResult> Handle(DeleteFileAssetCommand command, CancellationToken cancellationToken)
+    {
+        var fileAsset = await dbContext.FileAssets
+            .AsNoTracking()
+            .SingleOrDefaultAsync(f => f.Id == FileAssetId.Of(Guid.Parse(command.FileAssetId)), cancellationToken);
+
+        if (fileAsset is null)
+            throw new FileAssetNotFoundException(command.FileAssetId);
+
+
+        dbContext.FileAssets.Remove(fileAsset);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return new DeleteFileAssetResult(true);
+    }
+}

Backend/src/Modules/Nodes/Nodes.Api/Endpoints/Nodes/DeleteNode.cs

@@ -0,0 +1,25 @@
+using Nodes.Application.Entities.Nodes.Commands.DeleteNode;
+
+namespace Nodes.Api.Endpoints.Nodes;
+
+public class DeleteNode : ICarterModule
+{
+    public void AddRoutes(IEndpointRouteBuilder app)
+    {
+        app.MapDelete("/Nodes/{nodeId}", async (string nodeId, ISender sender) =>
+            {
+                var result = await sender.Send(new DeleteNodeCommand(nodeId));
+                var response = result.Adapt<DeleteNodeResponse>();
+
+                return Results.Ok(response);
+            })
+            .WithName("DeleteNode")
+            .Produces<DeleteNodeResponse>()
+            .ProducesProblem(StatusCodes.Status400BadRequest)
+            .ProducesProblem(StatusCodes.Status404NotFound)
+            .WithSummary("Delete Node")
+            .WithDescription("Delete Node");
+    }
+}
+
+public record DeleteNodeResponse(bool NodeDeleted);

Backend/src/Modules/Nodes/Nodes.Application/Entities/Nodes/Commands/DeleteNode/DeleteNodeCommand.cs

@@ -0,0 +1,13 @@
+namespace Nodes.Application.Entities.Nodes.Commands.DeleteNode;
+
+public record DeleteNodeCommand(string NodeId) : ICommand<DeleteNodeResult>;
+
+public record DeleteNodeResult(bool NodeDeleted);
+
+public class DeleteNodeCommandValidator : AbstractValidator<DeleteNodeCommand>
+{
+    public DeleteNodeCommandValidator()
+    {
+        RuleFor(x => x.NodeId).NotEmpty().WithMessage("NodeId is required");
+    }
+}

Backend/src/Modules/Nodes/Nodes.Application/Entities/Nodes/Commands/DeleteNode/DeleteNodeHandler.cs

@@ -0,0 +1,22 @@
+using Nodes.Application.Entities.Nodes.Exceptions;
+
+namespace Nodes.Application.Entities.Nodes.Commands.DeleteNode;
+
+public class DeleteNodeHandler(INodesDbContext dbContext) : ICommandHandler<DeleteNodeCommand, DeleteNodeResult>
+{
+    public async Task<DeleteNodeResult> Handle(DeleteNodeCommand command, CancellationToken cancellationToken)
+    {
+        var node = await dbContext.Nodes
+            .AsNoTracking()
+            .SingleOrDefaultAsync(n => n.Id == NodeId.Of(Guid.Parse(command.NodeId)), cancellationToken);
+
+        if (node is null)
+            throw new NodeNotFoundException(command.NodeId);
+
+
+        dbContext.Nodes.Remove(node);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return new DeleteNodeResult(true);
+    }
+}

Backend/src/Modules/Notes/Notes.Api/Endpoints/Notes/DeleteNote.cs

@@ -0,0 +1,25 @@
+using Notes.Application.Entities.Notes.Commands.DeleteNote;
+
+namespace Notes.Api.Endpoints.Notes;
+
+public class DeleteNote : ICarterModule
+{
+    public void AddRoutes(IEndpointRouteBuilder app)
+    {
+        app.MapDelete("/Notes/{noteId}", async (string noteId, ISender sender) =>
+            {
+                var result = await sender.Send(new DeleteNoteCommand(noteId));
+                var response = result.Adapt<DeleteNoteResponse>();
+
+                return Results.Ok(response);
+            })
+            .WithName("DeleteNote")
+            .Produces<DeleteNoteResponse>()
+            .ProducesProblem(StatusCodes.Status400BadRequest)
+            .ProducesProblem(StatusCodes.Status404NotFound)
+            .WithSummary("Delete Note")
+            .WithDescription("Delete Note");
+    }
+}
+
+public record DeleteNoteResponse(bool NoteDeleted);

Backend/src/Modules/Notes/Notes.Application/Entities/Notes/Commands/DeleteNote/DeleteNoteCommand.cs

@@ -0,0 +1,13 @@
+namespace Notes.Application.Entities.Notes.Commands.DeleteNote;
+
+public record DeleteNoteCommand(string NoteId) : ICommand<DeleteNoteResult>;
+
+public record DeleteNoteResult(bool NoteDeleted);
+
+public class DeleteNoteCommandValidator : AbstractValidator<DeleteNoteCommand>
+{
+    public DeleteNoteCommandValidator()
+    {
+        RuleFor(x => x.NoteId).NotEmpty().WithMessage("NoteId is required");
+    }
+}

Backend/src/Modules/Notes/Notes.Application/Entities/Notes/Commands/DeleteNote/DeleteNoteHandler.cs

@@ -0,0 +1,22 @@
+using Notes.Application.Entities.Notes.Exceptions;
+
+namespace Notes.Application.Entities.Notes.Commands.DeleteNote;
+
+public class DeleteNoteHandler(INotesDbContext dbContext) : ICommandHandler<DeleteNoteCommand, DeleteNoteResult>
+{
+    public async Task<DeleteNoteResult> Handle(DeleteNoteCommand command, CancellationToken cancellationToken)
+    {
+        var note = await dbContext.Notes
+            .AsNoTracking()
+            .SingleOrDefaultAsync(n => n.Id == NoteId.Of(Guid.Parse(command.NoteId)), cancellationToken);
+
+        if (note is null)
+            throw new NoteNotFoundException(command.NoteId);
+
+
+        dbContext.Notes.Remove(note);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return new DeleteNoteResult(true);
+    }
+}

Backend/src/Modules/Reminders/Reminders.Api/Endpoints/Reminders/DeleteReminder.cs

@@ -0,0 +1,25 @@
+using Reminders.Application.Entities.Reminders.Commands.DeleteReminder;
+
+namespace Reminders.Api.Endpoints.Reminders;
+
+public class DeleteReminder : ICarterModule
+{
+    public void AddRoutes(IEndpointRouteBuilder app)
+    {
+        app.MapDelete("/Reminders/{reminderId}", async (string reminderId, ISender sender) =>
+            {
+                var result = await sender.Send(new DeleteReminderCommand(reminderId));
+                var response = result.Adapt<DeleteReminderResponse>();
+
+                return Results.Ok(response);
+            })
+            .WithName("DeleteReminder")
+            .Produces<DeleteReminderResponse>()
+            .ProducesProblem(StatusCodes.Status400BadRequest)
+            .ProducesProblem(StatusCodes.Status404NotFound)
+            .WithSummary("Delete Reminder")
+            .WithDescription("Delete Reminder");
+    }
+}
+
+public record DeleteReminderResponse(bool ReminderDeleted);

Backend/src/Modules/Reminders/Reminders.Application/Entities/Reminders/Commands/DeleteReminder/DeleteReminderCommand.cs

@@ -0,0 +1,13 @@
+namespace Reminders.Application.Entities.Reminders.Commands.DeleteReminder;
+
+public record DeleteReminderCommand(string ReminderId) : ICommand<DeleteReminderResult>;
+
+public record DeleteReminderResult(bool ReminderDeleted);
+
+public class DeleteReminderCommandValidator : AbstractValidator<DeleteReminderCommand>
+{
+    public DeleteReminderCommandValidator()
+    {
+        RuleFor(x => x.ReminderId).NotEmpty().WithMessage("ReminderId is required");
+    }
+}

Backend/src/Modules/Reminders/Reminders.Application/Entities/Reminders/Commands/DeleteReminder/DeleteReminderHandler.cs

@@ -0,0 +1,22 @@
+using Reminders.Application.Entities.Reminders.Exceptions;
+
+namespace Reminders.Application.Entities.Reminders.Commands.DeleteReminder;
+
+public class DeleteReminderHandler(IRemindersDbContext dbContext) : ICommandHandler<DeleteReminderCommand, DeleteReminderResult>
+{
+    public async Task<DeleteReminderResult> Handle(DeleteReminderCommand command, CancellationToken cancellationToken)
+    {
+        var reminder = await dbContext.Reminders
+            .AsNoTracking()
+            .SingleOrDefaultAsync(r => r.Id == ReminderId.Of(Guid.Parse(command.ReminderId)), cancellationToken);
+
+        if (reminder is null)
+            throw new ReminderNotFoundException(command.ReminderId);
+
+
+        dbContext.Reminders.Remove(reminder);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return new DeleteReminderResult(true);
+    }
+}

Backend/src/Modules/Timelines/Timelines.Api/Endpoints/Timelines/DeleteTimeline.cs

@@ -0,0 +1,25 @@
+using Timelines.Application.Entities.Timelines.Commands.DeleteTimeline;
+
+namespace Timelines.Api.Endpoints.Timelines;
+
+public class DeleteTimeline : ICarterModule
+{
+    public void AddRoutes(IEndpointRouteBuilder app)
+    {
+        app.MapDelete("/Timelines/{timelineId}", async (string timelineId, ISender sender) =>
+            {
+                var result = await sender.Send(new DeleteTimelineCommand(timelineId));
+                var response = result.Adapt<DeleteTimelineResponse>();
+
+                return Results.Ok(response);
+            })
+            .WithName("DeleteTimeline")
+            .Produces<DeleteTimelineResponse>()
+            .ProducesProblem(StatusCodes.Status400BadRequest)
+            .ProducesProblem(StatusCodes.Status404NotFound)
+            .WithSummary("Delete Timeline")
+            .WithDescription("Delete Timeline");
+    }
+}
+
+public record DeleteTimelineResponse(bool TimelineDeleted);

Backend/src/Modules/Timelines/Timelines.Application/Entities/Timelines/Commands/DeleteTimeline/DeleteTimelineCommand.cs

@@ -0,0 +1,13 @@
+namespace Timelines.Application.Entities.Timelines.Commands.DeleteTimeline;
+
+public record DeleteTimelineCommand(string TimelineId) : ICommand<DeleteTimelineResult>;
+
+public record DeleteTimelineResult(bool TimelineDeleted);
+
+public class DeleteTimelineCommandValidator : AbstractValidator<DeleteTimelineCommand>
+{
+    public DeleteTimelineCommandValidator()
+    {
+        RuleFor(x => x.TimelineId).NotEmpty().WithMessage("TimelineId is required");
+    }
+}

Backend/src/Modules/Timelines/Timelines.Application/Entities/Timelines/Commands/DeleteTimeline/DeleteTimelineHandler.cs

@@ -0,0 +1,22 @@
+using Timelines.Application.Entities.Timelines.Exceptions;
+
+namespace Timelines.Application.Entities.Timelines.Commands.DeleteTimeline;
+
+public class DeleteNodeHandler(ITimelinesDbContext dbContext) : ICommandHandler<DeleteTimelineCommand, DeleteTimelineResult>
+{
+    public async Task<DeleteTimelineResult> Handle(DeleteTimelineCommand command, CancellationToken cancellationToken)
+    {
+        var timeline = await dbContext.Timelines
+        .AsNoTracking()
+            .SingleOrDefaultAsync(t => t.Id == TimelineId.Of(Guid.Parse(command.TimelineId)), cancellationToken);
+
+        if (timeline is null)
+            throw new TimelineNotFoundException(command.TimelineId);
+
+
+        dbContext.Timelines.Remove(timeline);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return new DeleteTimelineResult(true);
+    }
+}