chore: fix command fields

Author: HunorTotBagi

Backend/src/Modules/Nodes/Nodes.Application/Data/NodesService.cs

@@ -5,7 +5,6 @@
 using Mapster;
 using Microsoft.Extensions.DependencyInjection;
 using Nodes.Application.Data.Abstractions;
-using Nodes.Application.Entities.Nodes.Extensions;
 
 namespace Nodes.Application.Data;
 
@@ -14,7 +13,7 @@ public class NodesService(INodesRepository nodesRepository, IServiceProvider ser
     public async Task<NodeDto> GetNodeByIdAsync(NodeId nodeId, CancellationToken cancellationToken)
     {
         var node = await nodesRepository.GetNodeByIdAsync(nodeId, cancellationToken);
-        var nodeDto = node.ToNodeDto();
+        var nodeDto = node.Adapt<NodeDto>();
 
         var remindersService = serviceProvider.GetRequiredService<IRemindersService>();
 

Backend/src/Modules/Nodes/Nodes.Application/Entities/Nodes/Commands/CreateNode/CreateNodeCommand.cs

@@ -1,10 +1,21 @@
 using BuildingBlocks.Domain.Nodes.Node.Dtos;
 using BuildingBlocks.Domain.Nodes.Node.ValueObjects;
+using BuildingBlocks.Domain.Timelines.Timeline.ValueObjects;
 
 namespace Nodes.Application.Entities.Nodes.Commands.CreateNode;
 
 // ReSharper disable once ClassNeverInstantiated.Global
-public record CreateNodeCommand(NodeDto Node) : ICommand<CreateNodeResult>;
+public record CreateNodeCommand : ICommand<CreateNodeResult>
+{
+    public required string Title { get; set; }
+    public required string Description { get; set; }
+    public required string Phase { get; set; }
+    public required DateTime Timestamp { get; set; }
+    public required int Importance { get; set; }
+    public required List<string> Categories { get; set; }
+    public required List<string> Tags { get; set; }
+    public required TimelineId TimelineId { get; set; }
+}
 
 // ReSharper disable once NotAccessedPositionalProperty.Global
 public record CreateNodeResult(NodeId Id);
@@ -13,40 +24,40 @@ public class CreateNodeCommandValidator : AbstractValidator<CreateNodeCommand>
 {
     public CreateNodeCommandValidator()
     {
-        RuleFor(x => x.Node.Title)
+        RuleFor(x => x.Title)
             .NotEmpty().WithMessage("Title is required.")
             .MaximumLength(100).WithMessage("Title must not exceed 100 characters.");
 
-        RuleFor(x => x.Node.Description)
+        RuleFor(x => x.Description)
             .NotEmpty().WithMessage("Description is required.")
             .MaximumLength(500).WithMessage("Description must not exceed 500 characters.");
 
-        RuleFor(x => x.Node.Timestamp)
+        RuleFor(x => x.Timestamp)
             .LessThanOrEqualTo(DateTime.Now).WithMessage("Timestamp cannot be in the future.");
 
-        RuleFor(x => x.Node.Importance)
+        RuleFor(x => x.Importance)
             .InclusiveBetween(1, 10).WithMessage("Importance must be between 1 and 10.");
 
-        RuleFor(x => x.Node.Phase)
+        RuleFor(x => x.Phase)
             .NotEmpty().WithMessage("Phase is required.");
 
-        RuleFor(x => x.Node)
+        RuleFor(x => x)
             .NotNull().WithMessage("Node cannot be null.")
             .DependentRules(() =>
             {
-                RuleFor(x => x.Node.Categories)
+                RuleFor(x => x.Categories)
                     .Must(categories => categories != null && categories.Count > 0)
                     .WithMessage("At least one category must be provided.");
 
-                RuleFor(x => x.Node.Tags)
+                RuleFor(x => x.Tags)
                     .Must(tags => tags != null && tags.Count > 0)
                     .WithMessage("At least one tag must be provided.");
             });
 
-        RuleForEach(x => x.Node.Categories)
+        RuleForEach(x => x.Categories)
             .MaximumLength(50).WithMessage("Category must not exceed 50 characters.");
 
-        RuleForEach(x => x.Node.Tags)
+        RuleForEach(x => x.Tags)
             .MaximumLength(50).WithMessage("Tag must not exceed 50 characters.");
     }
 }

Backend/src/Modules/Nodes/Nodes.Application/Entities/Nodes/Commands/CreateNode/CreateNodeHandler.cs

@@ -22,13 +22,14 @@ public static Node ToNode(this CreateNodeCommand command)
     {
         return Node.Create(
             NodeId.Of(Guid.NewGuid()),
-            command.Node.Title,
-            command.Node.Description,
-            command.Node.Phase,
-            command.Node.Timestamp,
-            command.Node.Importance,
-            command.Node.Categories,
-            command.Node.Tags
+            command.Title,
+            command.Description,
+            command.Phase,
+            command.Timestamp,
+            command.Importance,
+            command.Categories,
+            command.Tags,
+            command.TimelineId
         );
     }
 }

Backend/src/Modules/Nodes/Nodes.Application/Entities/Nodes/Extensions/NodeExtensions.cs

@@ -1,10 +1,11 @@
 using BuildingBlocks.Domain.Nodes.Node.Dtos;
+using BuildingBlocks.Domain.Timelines.Timeline.Dtos;
 
 namespace Nodes.Application.Entities.Nodes.Extensions;
 
 public static class NodeExtensions
 {
-    public static NodeDto ToNodeDto(this Node node)
+    public static NodeDto ToNodeDto(this Node node, TimelineBaseDto timeline)
     {
         return new NodeDto(
             node.Id.ToString(),
@@ -14,11 +15,7 @@ public static NodeDto ToNodeDto(this Node node)
             node.Importance,
             node.Phase,
             node.Categories.ToList(),
-            node.Tags.ToList());
-    }
-
-    public static IEnumerable<NodeDto> ToNodeDtoList(this IEnumerable<Node> nodes)
-    {
-        return nodes.Select(ToNodeDto);
+            node.Tags.ToList(),
+            timeline);
     }
 }

Backend/src/Modules/Nodes/Nodes.Application/Entities/Nodes/Queries/ListNodes/ListNodesHandler.cs

@@ -1,11 +1,12 @@
+using BuildingBlocks.Application.Data;
 using BuildingBlocks.Application.Pagination;
 using BuildingBlocks.Domain.Nodes.Node.Dtos;
 using Nodes.Application.Data.Abstractions;
 using Nodes.Application.Entities.Nodes.Extensions;
 
 namespace Nodes.Application.Entities.Nodes.Queries.ListNodes;
 
-internal class ListNodesHandler(INodesDbContext dbContext) : IQueryHandler<ListNodesQuery, ListNodesResult>
+internal class ListNodesHandler(INodesDbContext dbContext, ITimelinesService timelinesService) : IQueryHandler<ListNodesQuery, ListNodesResult>
 {
     // todo: Refactor so that Services are used
     public async Task<ListNodesResult> Handle(ListNodesQuery query, CancellationToken cancellationToken)
@@ -22,11 +23,17 @@ public async Task<ListNodesResult> Handle(ListNodesQuery query, CancellationToke
             .Take(pageSize)
             .ToListAsync(cancellationToken: cancellationToken);
 
+        var nodeDtos = nodes.Select(n =>
+        {
+            var timeline = timelinesService.GetTimelineBaseDtoAsync(n.TimelineId, cancellationToken).GetAwaiter().GetResult();
+            return n.ToNodeDto(timeline);
+        }).ToList();
+
         return new ListNodesResult(
             new PaginatedResult<NodeDto>(
                 pageIndex,
                 pageSize,
                 totalCount,
-                nodes.ToNodeDtoList()));
+                nodeDtos));
     }
 }

Backend/src/Modules/Nodes/Nodes.Domain/Models/Node.cs

@@ -19,9 +19,10 @@ public class Node : Aggregate<NodeId>
 
     public required string Title { get; set; }
     public required string Description { get; set; }
+    public required string Phase { get; set; }
     public required DateTime Timestamp { get; set; }
     public required int Importance { get; set; }
-    public required string Phase { get; set; }
+
     public List<ReminderId> ReminderIds { get; set; } = [];
     public required TimelineId TimelineId { get; set; }
 

Backend/src/Modules/Timelines/Timelines.Application/Entities/Timelines/Queries/GetTimelineById/GetTimelineByIdHandler.cs

@@ -1,20 +1,17 @@
-using Timelines.Application.Data.Abstractions;
+using BuildingBlocks.Application.Data;
 using Timelines.Application.Entities.Timelines.Exceptions;
-using Timelines.Application.Entities.Timelines.Extensions;
 
 namespace Timelines.Application.Entities.Timelines.Queries.GetTimelineById;
 
-internal class GetTimelineByIdHandler(ITimelinesDbContext dbContext) : IQueryHandler<GetTimelineByIdQuery, GetTimelineByIdResult>
+internal class GetTimelineByIdHandler(ITimelinesService timelinesService) : IQueryHandler<GetTimelineByIdQuery, GetTimelineByIdResult>
 {
     public async Task<GetTimelineByIdResult> Handle(GetTimelineByIdQuery query, CancellationToken cancellationToken)
     {
-        var timeline = await dbContext.Timelines
-            .AsNoTracking()
-            .SingleOrDefaultAsync(t => t.Id == query.Id, cancellationToken);
+        var timelineDto = await timelinesService.GetTimelineById(query.Id, cancellationToken);
 
-        if (timeline is null)
+        if (timelineDto is null)
             throw new TimelineNotFoundException(query.Id.ToString());
 
-        return new GetTimelineByIdResult(timeline.ToTimelineDto());
+        return new GetTimelineByIdResult(timelineDto);
     }
 }