Added Service to Server Tree Command

RackPeek.Domain/Resources/Hardware/Servers/GetServerSystemTreeUseCase.cs

@@ -1,25 +1,51 @@
 using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.Services;
 using RackPeek.Domain.Resources.SystemResources;
 
 namespace RackPeek.Domain.Resources.Hardware.Servers;
 
 public class GetServerSystemTreeUseCase(
     IHardwareRepository hardwareRepository,
-    ISystemRepository systemRepository)
+    ISystemRepository systemRepository,
+    IServiceRepository serviceRepository)
 {
     public async Task<HardwareDependencyTree?> ExecuteAsync(string hardwareName)
     {
         var server = await hardwareRepository.GetByNameAsync(hardwareName) as Server;
         if (server is null) return null;
 
-        var systems = await systemRepository.GetByPhysicalHostAsync(hardwareName);
+        return await BuildDependencyTreeAsync(server);
+    }
+
+    private async Task<HardwareDependencyTree> BuildDependencyTreeAsync(Server server)
+    {
+        var systems = await systemRepository.GetByPhysicalHostAsync(server.Name);
+
+        var systemTrees = new List<SystemDependencyTree>();
+        foreach (var system in systems)
+        {
+            systemTrees.Add(await BuildSystemDependencyTreeAsync(system));
+        }
+
+        return new HardwareDependencyTree(server, systemTrees);
+    }
 
-        return new HardwareDependencyTree(server, systems);
+    private async Task<SystemDependencyTree> BuildSystemDependencyTreeAsync(SystemResource system)
+    {
+        var services = await serviceRepository.GetBySystemHostAsync(system.Name);
+
+        return new SystemDependencyTree(system, services);
     }
 }
 
-public sealed class HardwareDependencyTree(Server hardware, IReadOnlyList<SystemResource> systems)
+public sealed class HardwareDependencyTree(Server hardware, IEnumerable<SystemDependencyTree> systems)
 {
     public Server Hardware { get; } = hardware;
-    public IReadOnlyList<SystemResource> Systems { get; } = systems;
-}
+    public IEnumerable<SystemDependencyTree> Systems { get; } = systems;
+}
+
+public sealed class SystemDependencyTree(SystemResource system, IEnumerable<Service> services)
+{
+    public SystemResource System { get; } = system;
+    public IEnumerable<Service> Services { get; } = services;
+}

RackPeek.Domain/Resources/Services/Service.cs

@@ -4,6 +4,34 @@ public class Service : Resource
 {
     public Network? Network { get; set; }
     public string? RunsOn { get; set; }
+
+    public string NetworkString()
+    {
+        if (Network == null)
+        {
+            return string.Empty;
+        }
+        
+        if (!string.IsNullOrEmpty(Network.Url))
+        {
+            return Network.Url;
+        }
+
+        var stringBuilder = new System.Text.StringBuilder();
+        if (!string.IsNullOrEmpty(Network.Ip))
+        {
+            stringBuilder.Append("Ip: ");
+            stringBuilder.Append(Network.Ip);
+            if (Network.Port.HasValue)
+            {
+                stringBuilder.Append(':');
+                stringBuilder.Append(Network.Port.Value);
+            }
+            stringBuilder.Append(' ');
+        }
+        
+        return stringBuilder.ToString();
+    }
 }
 
 public class Network

RackPeek/Commands/Servers/ServerTreeCommand.cs

@@ -21,7 +21,14 @@ public sealed class ServerTreeCommand(GetServerSystemTreeUseCase useCase) : Asyn
 
         var root = new Tree($"[bold]{tree.Hardware.Name}[/]");
 
-        foreach (var system in tree.Systems) root.AddNode($"[green]System:[/] {system.Name}");
+        foreach (var system in tree.Systems)
+        {
+            var systemNode = root.AddNode($"[green]System:[/] {system.System.Name}");
+            foreach (var service in system.Services)
+            {
+                systemNode.AddNode($"[green]Service:[/] {service.Name}");
+            }
+        }
 
         AnsiConsole.Write(root);
         return 0;

Tests/EndToEnd/ServerYamlE2ETests.cs

@@ -69,14 +69,33 @@ public class ServerYamlE2ETests(TempYamlCliFixture fs, ITestOutputHelper outputH
             "--runs-on", "node01"
         );
         Assert.Equal("System 'host03' updated.\n", output);
+        
+        
+        (output, yaml) = await ExecuteAsync("services", "add", "immich");
+        Assert.Equal("Service 'immich' added.\n", output);
+        
+        (output, yaml) = await ExecuteAsync("services", "add", "paperless");
+        Assert.Equal("Service 'paperless' added.\n", output);
+        
+        (output, yaml) = await ExecuteAsync(
+            "services", "set", "immich",
+            "--runs-on", "host01"
+        );
+        
+        (output, yaml) = await ExecuteAsync(
+            "services", "set", "paperless",
+            "--runs-on", "host01"
+        );
 
         (output, yaml) = await ExecuteAsync("servers", "tree", "node01");
         Assert.Equal("""
                      node01
                      ├── System: host01
+                     │   ├── Service: immich
+                     │   └── Service: paperless
                      ├── System: host02
                      └── System: host03
-
+                     
                      """, output);
     }
 }