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,15 @@
+namespace Files.Application.Entities.Files.Commands.DeleteFileAsset;
+
+public record DeleteFileAssetCommand(string Id) : ICommand<DeleteFileAssetResult>;
+
+public record DeleteFileAssetResult(bool FileDeleted);
+
+public class DeleteFileAssetCommandValidator : AbstractValidator<DeleteFileAssetCommand>
+{
+    public DeleteFileAssetCommandValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("Id is required.")
+            .Must(value => Guid.TryParse(value.ToString(), out _)).WithMessage("Id is not valid.");
+    }
+}

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

@@ -0,0 +1,21 @@
+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.Id)), cancellationToken);
+
+        if (fileAsset is null)
+            throw new FileAssetNotFoundException(command.Id);
+
+        dbContext.FileAssets.Remove(fileAsset);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return new DeleteFileAssetResult(true);
+    }
+}

Backend/src/Modules/Files/Files.Application/Entities/Files/Queries/GetFileAssetById/GetFileAssetByIdHandler.cs

@@ -7,12 +7,14 @@ internal class GetFileAssetByIdHandler(IFilesDbContext dbContext) : IQueryHandle
 {
     public async Task<GetFileAssetByIdResult> Handle(GetFileAssetByIdQuery query, CancellationToken cancellationToken)
     {
+        var fileAssetId = query.Id.ToString();
+
         var fileAsset = await dbContext.FileAssets
             .AsNoTracking()
-            .SingleOrDefaultAsync(f => f.Id == FileAssetId.Of(Guid.Parse(query.Id)), cancellationToken);
+            .SingleOrDefaultAsync(f => f.Id == FileAssetId.Of(Guid.Parse(fileAssetId)), cancellationToken);
 
         if (fileAsset is null)
-            throw new FileAssetNotFoundException(query.Id);
+            throw new FileAssetNotFoundException(fileAssetId);
 
         return new GetFileAssetByIdResult(fileAsset.ToFileAssetDto());
     }

Backend/src/Modules/Files/Files.Application/Entities/Files/Queries/GetFileAssetById/GetFileAssetByIdQuery.cs

@@ -4,7 +4,20 @@
 
 namespace Files.Application.Entities.Files.Queries.GetFileAssetById;
 
-public record GetFileAssetByIdQuery(string Id) : IQuery<GetFileAssetByIdResult>;
+public record GetFileAssetByIdQuery(FileAssetId Id) : IQuery<GetFileAssetByIdResult>
+{
+    public GetFileAssetByIdQuery(string Id) : this(FileAssetId.Of(Guid.Parse(Id))) { }
+}
 
 // ReSharper disable once NotAccessedPositionalProperty.Global
 public record GetFileAssetByIdResult(FileAssetDto FileAssetDto);
+
+public class GetFileAssetByIdQueryValidator : AbstractValidator<GetFileAssetByIdQuery>
+{
+    public GetFileAssetByIdQueryValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("Id is required.")
+            .Must(value => Guid.TryParse(value.ToString(), out _)).WithMessage("Id is not valid.");
+    }
+}

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,15 @@
+namespace Nodes.Application.Entities.Nodes.Commands.DeleteNode;
+
+public record DeleteNodeCommand(string Id) : ICommand<DeleteNodeResult>;
+
+public record DeleteNodeResult(bool NodeDeleted);
+
+public class DeleteNodeCommandValidator : AbstractValidator<DeleteNodeCommand>
+{
+    public DeleteNodeCommandValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("Id is required.")
+            .Must(value => Guid.TryParse(value.ToString(), out _)).WithMessage("Id is not valid.");
+    }
+}

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

@@ -0,0 +1,21 @@
+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.Id)), cancellationToken);
+
+        if (node is null)
+            throw new NodeNotFoundException(command.Id);
+
+        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,15 @@
+namespace Notes.Application.Entities.Notes.Commands.DeleteNote;
+
+public record DeleteNoteCommand(string Id) : ICommand<DeleteNoteResult>;
+
+public record DeleteNoteResult(bool NoteDeleted);
+
+public class DeleteNoteCommandValidator : AbstractValidator<DeleteNoteCommand>
+{
+    public DeleteNoteCommandValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("Id is required.")
+            .Must(value => Guid.TryParse(value.ToString(), out _)).WithMessage("Id is not valid.");
+    }
+}

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

@@ -0,0 +1,21 @@
+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.Id)), cancellationToken);
+
+        if (note is null)
+            throw new NoteNotFoundException(command.Id);
+
+        dbContext.Notes.Remove(note);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return new DeleteNoteResult(true);
+    }
+}

Backend/src/Modules/Notes/Notes.Application/Entities/Notes/Queries/GetNoteById/GetNoteByIdHandler.cs

@@ -7,12 +7,14 @@ internal class GetNoteByIdHandler(INotesDbContext dbContext) : IQueryHandler<Get
 {
     public async Task<GetNoteByIdResult> Handle(GetNoteByIdQuery query, CancellationToken cancellationToken)
     {
+        var noteId = query.Id.ToString();
+
         var note = await dbContext.Notes
             .AsNoTracking()
-            .SingleOrDefaultAsync(n => n.Id == NoteId.Of(Guid.Parse(query.Id)), cancellationToken);
+            .SingleOrDefaultAsync(n => n.Id == NoteId.Of(Guid.Parse(noteId)), cancellationToken);
 
         if (note is null)
-            throw new NoteNotFoundException(query.Id);
+            throw new NoteNotFoundException(noteId);
 
         return new GetNoteByIdResult(note.ToNoteDto());
     }

Backend/src/Modules/Notes/Notes.Application/Entities/Notes/Queries/GetNoteById/GetNoteByIdQuery.cs

@@ -1,7 +1,23 @@
-using Notes.Application.Entities.Notes.Dtos;
+// ReSharper disable ClassNeverInstantiated.Global
+
+using Notes.Application.Entities.Notes.Dtos;
 
 namespace Notes.Application.Entities.Notes.Queries.GetNoteById;
 
-public record GetNoteByIdQuery(string Id) : IQuery<GetNoteByIdResult>;
+public record GetNoteByIdQuery(NoteId Id) : IQuery<GetNoteByIdResult>
+{
+    public GetNoteByIdQuery(string Id) : this(NoteId.Of(Guid.Parse(Id))) { }
+}
 
+// ReSharper disable once NotAccessedPositionalProperty.Global
 public record GetNoteByIdResult(NoteDto NoteDto);
+
+public class GetNoteByIdQueryValidator : AbstractValidator<GetNoteByIdQuery>
+{
+    public GetNoteByIdQueryValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("Id is required.")
+            .Must(value => Guid.TryParse(value.ToString(), out _)).WithMessage("Id is not valid.");
+    }
+}

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,15 @@
+namespace Reminders.Application.Entities.Reminders.Commands.DeleteReminder;
+
+public record DeleteReminderCommand(string Id) : ICommand<DeleteReminderResult>;
+
+public record DeleteReminderResult(bool ReminderDeleted);
+
+public class DeleteReminderCommandValidator : AbstractValidator<DeleteReminderCommand>
+{
+    public DeleteReminderCommandValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("Id is required.")
+            .Must(value => Guid.TryParse(value.ToString(), out _)).WithMessage("Id is not valid.");
+    }
+}

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

@@ -0,0 +1,21 @@
+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.Id)), cancellationToken);
+
+        if (reminder is null)
+            throw new ReminderNotFoundException(command.Id);
+
+        dbContext.Reminders.Remove(reminder);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return new DeleteReminderResult(true);
+    }
+}

Backend/src/Modules/Reminders/Reminders.Application/Entities/Reminders/Queries/GetReminderById/GetReminderByIdHandler.cs

@@ -7,12 +7,14 @@ internal class GetReminderByIdHandler(IRemindersDbContext dbContext) : IQueryHan
 {
     public async Task<GetReminderByIdResult> Handle(GetReminderByIdQuery query, CancellationToken cancellationToken)
     {
+        var reminderId = query.Id.ToString();
+
         var reminder = await dbContext.Reminders
             .AsNoTracking()
-            .SingleOrDefaultAsync(r => r.Id == ReminderId.Of(Guid.Parse(query.Id)), cancellationToken);
+            .SingleOrDefaultAsync(r => r.Id == ReminderId.Of(Guid.Parse(reminderId)), cancellationToken);
 
         if (reminder is null)
-            throw new ReminderNotFoundException(query.Id);
+            throw new ReminderNotFoundException(reminderId);
 
         return new GetReminderByIdResult(reminder.ToReminderDto());
     }

Backend/src/Modules/Reminders/Reminders.Application/Entities/Reminders/Queries/GetReminderById/GetReminderByIdQuery.cs

@@ -4,7 +4,20 @@
 
 namespace Reminders.Application.Entities.Reminders.Queries.GetReminderById;
 
-public record GetReminderByIdQuery(string Id) : IQuery<GetReminderByIdResult>;
+public record GetReminderByIdQuery(ReminderId Id) : IQuery<GetReminderByIdResult>
+{
+    public GetReminderByIdQuery(string Id) : this(ReminderId.Of(Guid.Parse(Id))) { }
+}
 
 // ReSharper disable once NotAccessedPositionalProperty.Global
 public record GetReminderByIdResult(ReminderDto ReminderDto);
+
+public class GetReminderByIdQueryValidator : AbstractValidator<GetReminderByIdQuery>
+{
+    public GetReminderByIdQueryValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEmpty().WithMessage("Id is required.")
+            .Must(value => Guid.TryParse(value.ToString(), out _)).WithMessage("Id is not valid.");
+    }
+}