Update Timeline Model and Establish Relationship with Node Entity

Backend/src/BuildingBlocks/BuildingBlocks.Api/Converters/TimelineIdConverter.cs

@@ -1,4 +1,4 @@
-using BuildingBlocks.Domain.ValueObjects.Ids;
+using BuildingBlocks.Domain.Timelines.Timeline.ValueObjects;
 
 namespace BuildingBlocks.Api.Converters;
 

Backend/src/BuildingBlocks/BuildingBlocks.Application/Data/ITimelinesService.cs

@@ -0,0 +1,12 @@
+using BuildingBlocks.Domain.Nodes.Node.ValueObjects;
+using BuildingBlocks.Domain.Timelines.Timeline.Dtos;
+using BuildingBlocks.Domain.Timelines.Timeline.ValueObjects;
+
+namespace BuildingBlocks.Application.Data;
+
+public interface ITimelinesService
+{
+    Task<TimelineDto> GetTimelineByIdAsync(TimelineId timelineId, CancellationToken cancellationToken);
+    Task<TimelineBaseDto> GetTimelineBaseDtoAsync(TimelineId timelineId, CancellationToken cancellationToken);
+    Task AddNode(TimelineId timelineId, NodeId nodeId, CancellationToken cancellationToken);
+}

Backend/src/BuildingBlocks/BuildingBlocks.Domain/Nodes/Node/Dtos/NodeDto.cs

@@ -1,5 +1,6 @@
 using System.Text.Json.Serialization;
 using BuildingBlocks.Domain.Reminders.Reminder.Dtos;
+using BuildingBlocks.Domain.Timelines.Timeline.Dtos;
 
 namespace BuildingBlocks.Domain.Nodes.Node.Dtos;
 
@@ -11,7 +12,9 @@ public class NodeDto(
     int importance,
     string phase,
     List<string> categories,
-    List<string> tags) : NodeBaseDto(id, title, description, timestamp, importance, phase, categories, tags)
+    List<string> tags,
+    TimelineBaseDto timeline) : NodeBaseDto(id, title, description, timestamp, importance, phase, categories, tags)
 {
     [JsonPropertyName("reminders")] public List<ReminderBaseDto> Reminders { get; } = [];
+    [JsonPropertyName("timelines")] public TimelineBaseDto Timeline { get; set; } = timeline;
 }

Backend/src/Modules/Timelines/Timelines.Application/Entities/Timelines/Dtos/TimelineDto.cs → Backend/src/BuildingBlocks/BuildingBlocks.Domain/Timelines/Timeline/Dtos/TimelineBaseDto.cs

@@ -1,8 +1,8 @@
 using System.Text.Json.Serialization;
 
-namespace Timelines.Application.Entities.Timelines.Dtos;
+namespace BuildingBlocks.Domain.Timelines.Timeline.Dtos;
 
-public class TimelineDto(
+public class TimelineBaseDto(
     string? id,
     string title)
 {

Backend/src/BuildingBlocks/BuildingBlocks.Domain/Timelines/Timeline/Dtos/TimelineDto.cs

@@ -0,0 +1,11 @@
+using System.Text.Json.Serialization;
+using BuildingBlocks.Domain.Nodes.Node.Dtos;
+
+namespace BuildingBlocks.Domain.Timelines.Timeline.Dtos;
+
+public class TimelineDto(
+    string? id,
+    string title) : TimelineBaseDto(id, title)
+{
+    [JsonPropertyName("nodes")] public List<NodeBaseDto> Nodes { get; } = [];
+}

Backend/src/BuildingBlocks/BuildingBlocks.Domain/Timelines/Timeline/Events/TimelineCreatedEvent.cs

@@ -0,0 +1,6 @@
+using BuildingBlocks.Domain.Abstractions;
+using BuildingBlocks.Domain.Timelines.Timeline.ValueObjects;
+
+namespace BuildingBlocks.Domain.Timelines.Timeline.Events;
+
+public record TimelineCreatedEvent(TimelineId TimelineId) : IDomainEvent;

Backend/src/BuildingBlocks/BuildingBlocks.Domain/Timelines/Timeline/Events/TimelineUpdatedEvent.cs

@@ -0,0 +1,6 @@
+using BuildingBlocks.Domain.Abstractions;
+using BuildingBlocks.Domain.Timelines.Timeline.ValueObjects;
+
+namespace BuildingBlocks.Domain.Timelines.Timeline.Events;
+
+public record TimelineUpdatedEvent(TimelineId TimelineId) : IDomainEvent;

Backend/src/BuildingBlocks/BuildingBlocks.Domain/Timelines/Timeline/ValueObjects/TimelineId.cs

@@ -0,0 +1,77 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using BuildingBlocks.Domain.Abstractions;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace BuildingBlocks.Domain.Timelines.Timeline.ValueObjects;
+
+[JsonConverter(typeof(TimelineIdJsonConverter))]
+public class TimelineId : StronglyTypedId
+{
+    private TimelineId(Guid value) : base(value) { }
+
+    public static TimelineId Of(Guid value) => new(value);
+
+    public override string ToString() => Value.ToString();
+
+    public override bool Equals(object? obj)
+    {
+        return obj is TimelineId other && Value == other.Value;
+    }
+
+    public override int GetHashCode()
+    {
+        return Value.GetHashCode();
+    }
+}
+
+public class TimelineIdValueConverter : ValueConverter<TimelineId, Guid>
+{
+    public TimelineIdValueConverter()
+        : base(
+            timelineId => timelineId.Value, // Convert from NodeId to Guid
+            guid => TimelineId.Of(guid)) // Convert from Guid to NodeId
+    {
+    }
+}
+
+public class TimelineIdJsonConverter : JsonConverter<TimelineId>
+{
+    public override TimelineId Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        // ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault
+        switch (reader.TokenType)
+        {
+            case JsonTokenType.String:
+                {
+                    var guidString = reader.GetString();
+                    if (!Guid.TryParse(guidString, out var guid))
+                        throw new JsonException($"Invalid GUID format for TimelineId: {guidString}");
+
+                    return TimelineId.Of(guid);
+                }
+            case JsonTokenType.StartObject:
+                {
+                    using var jsonDoc = JsonDocument.ParseValue(ref reader);
+
+                    if (!jsonDoc.RootElement.TryGetProperty("id", out JsonElement idElement))
+                        throw new JsonException("Expected property 'id' not found.");
+
+                    var guidString = idElement.GetString();
+
+                    if (!Guid.TryParse(guidString, out var guid))
+                        throw new JsonException($"Invalid GUID format for TimelineId: {guidString}");
+
+                    return TimelineId.Of(guid);
+                }
+            default:
+                throw new JsonException(
+                    $"Unexpected token parsing TimelineId. Expected String or StartObject, got {reader.TokenType}.");
+        }
+    }
+
+    public override void Write(Utf8JsonWriter writer, TimelineId value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}

Backend/src/Modules/Files/Files.Infrastructure/GlobalUsing.cs

@@ -1,5 +1,4 @@
 global using Microsoft.EntityFrameworkCore;
 global using Microsoft.Extensions.DependencyInjection;
-global using BuildingBlocks.Domain.Abstractions;
 global using BuildingBlocks.Domain.ValueObjects.Ids;
 global using Files.Domain.Models;

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

@@ -1,5 +1,7 @@
-using BuildingBlocks.Domain.Nodes.Node.Dtos;
+using System;
+using System.Collections.Generic;
 using BuildingBlocks.Domain.Nodes.Node.ValueObjects;
+using BuildingBlocks.Domain.Timelines.Timeline.ValueObjects;
 using Nodes.Application.Entities.Nodes.Commands.CreateNode;
 
 // ReSharper disable ClassNeverInstantiated.Global
@@ -30,11 +32,14 @@ public void AddRoutes(IEndpointRouteBuilder app)
 
 public class CreateNodeRequest
 {
-    public CreateNodeRequest() { }
-
-    public CreateNodeRequest(NodeDto node) => Node = node;
-
-    public NodeDto Node { get; set; }
+    public string Title { get; set; }
+    public string Description { get; set; }
+    public DateTime Timestamp { get; set; }
+    public int Importance { get; set; }
+    public string Phase { get; set; }
+    public List<string> Categories { get; set; }
+    public List<string> Tags { get; set; }
+    public TimelineId TimelineId { get; set; }
 }
 
 public record CreateNodeResponse(NodeId Id);

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

@@ -11,8 +11,8 @@ public void AddRoutes(IEndpointRouteBuilder app)
     {
         app.MapGet("/Nodes/{nodeId}", async (string nodeId, ISender sender) =>
         {
-            var result = await sender.Send(new GetNodeByIdQuery(nodeId));
-            var response = result.Adapt<GetNodeByIdResponse>();
+            var result = await sender.Send(new GetNodeByIdQuery(nodeId));
+            var response = new GetNodeByIdResponse(result.NodeDto);
 
             return Results.Ok(response);
         })

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

@@ -11,7 +11,7 @@ public void AddRoutes(IEndpointRouteBuilder app)
         app.MapGet("/Nodes", async ([AsParameters] PaginationRequest query, ISender sender) =>
         {
             var result = await sender.Send(new ListNodesQuery(query));
-            var response = result.Adapt<ListNodesResponse>();
+            var response = new ListNodesResponse(result.Nodes);
 
             return Results.Ok(response);
         })

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

@@ -2,6 +2,7 @@
 using BuildingBlocks.Domain.Nodes.Node.Dtos;
 using BuildingBlocks.Domain.Nodes.Node.ValueObjects;
 using BuildingBlocks.Domain.Reminders.Reminder.ValueObjects;
+using BuildingBlocks.Domain.Timelines.Timeline.Dtos;
 using Mapster;
 using Microsoft.Extensions.DependencyInjection;
 using Nodes.Application.Data.Abstractions;
@@ -14,7 +15,11 @@ 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 timelineService = serviceProvider.GetRequiredService<ITimelinesService>();
+        var timeline = await timelineService.GetTimelineBaseDtoAsync(node.TimelineId, cancellationToken);
+
+        var nodeDto = node.ToNodeDto(timeline);
 
         var remindersService = serviceProvider.GetRequiredService<IRemindersService>();
 

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

@@ -1,10 +1,20 @@
-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 +23,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.");
     }
 }