✨ Basic api endpoints

#1

OpenMediaServer/Endpoints/ApiEndpoints.cs

@@ -0,0 +1,47 @@
+using System;
+using OpenMediaServer.Interfaces.Endpoints;
+using OpenMediaServer.Interfaces.Services;
+
+namespace OpenMediaServer.Endpoints;
+
+public class ApiEndpoints : IApiEndpoints
+{
+    private readonly ILogger<ApiEndpoints> _logger;
+    private readonly IInventoryService _inventoryService;
+
+    public ApiEndpoints(ILogger<ApiEndpoints> logger, IInventoryService inventoryService)
+    {
+        _logger = logger;
+        _inventoryService = inventoryService;
+    }
+
+    public void Map(WebApplication app)
+    {
+        var group = app.MapGroup("/api");
+
+        group.MapGet("/categories", ListCategories);
+        group.MapGet("/items", ListItems);
+        group.MapGet("/item", GetItem);
+    }
+
+    public async Task<IResult> ListCategories()
+    {
+        var categories = await _inventoryService.ListCategories();
+
+        return Results.Ok(categories);
+    }
+
+    public async Task<IResult> ListItems(string category)
+    {
+        var items = await _inventoryService.ListItems(category);
+
+        return Results.Ok(items);
+    }
+
+    public async Task<IResult> GetItem(string category, string id)
+    {
+        var item = await _inventoryService.GetItem(id: id, category: category);
+
+        return Results.Ok(item);
+    }
+}

OpenMediaServer/Endpoints/StreamingEndpoints.cs

@@ -0,0 +1,31 @@
+using System;
+using OpenMediaServer.Interfaces.Endpoints;
+using OpenMediaServer.Interfaces.Services;
+
+namespace OpenMediaServer.Endpoints;
+
+public class StreamingEndpoints : IStreamingEndpoints
+{
+    private readonly ILogger<StreamingEndpoints> _logger;
+    private readonly IStreamingService _streamingService;
+
+    public StreamingEndpoints(ILogger<StreamingEndpoints> logger, IStreamingService streamingService)
+    {
+        _logger = logger;
+        _streamingService = streamingService;
+    }
+
+    public void Map(WebApplication app)
+    {
+        var group = app.MapGroup("/stream");
+
+        group.MapGet("/{category}/{id}", StreamContent);
+    }
+
+    public async Task<IResult> StreamContent(string id, string category)
+    {
+        using var stream = await _streamingService.GetMediaStream(id, category);
+
+        return Results.Stream(stream, enableRangeProcessing: true, contentType: "video/webm"); // TODO content type
+    }
+}

OpenMediaServer/Interfaces/Endpoints/IMovieEndpoints.cs → OpenMediaServer/Interfaces/Endpoints/IApiEndpoints.cs

@@ -2,7 +2,7 @@
 
 namespace OpenMediaServer.Interfaces.Endpoints;
 
-public interface IMovieEndpoints
+public interface IApiEndpoints
 {
     public void Map(WebApplication app);
 }

OpenMediaServer/Interfaces/Endpoints/IStreamingEndpoints.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace OpenMediaServer.Interfaces.Endpoints;
+
+public interface IStreamingEndpoints
+{
+    public void Map(WebApplication app);
+}

OpenMediaServer/Interfaces/Services/IInventoryService.cs

@@ -8,4 +8,7 @@ public interface IInventoryService
     public void AddItem<T>(T item) where T : InventoryItem;
     public void AddItems(IEnumerable<InventoryItem> items);
     public void CreateFromPaths(IEnumerable<string> paths);
+    public Task<IEnumerable<string>> ListCategories();
+    public Task<IEnumerable<InventoryItem>> ListItems(string category);
+    public Task<InventoryItem> GetItem(string id, string category);
 }

OpenMediaServer/Interfaces/Services/IStreamingService.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace OpenMediaServer.Interfaces.Services;
+
+public interface IStreamingService
+{
+    public Task<Stream> GetMediaStream(string id, string category);
+}

OpenMediaServer/Program.cs

@@ -16,26 +16,25 @@
 builder.Services.AddSingleton<IContentDiscoveryService, ContentDiscoveryService>();
 builder.Services.AddSingleton<IStorageRepository, FileSystemRepository>();
 builder.Services.AddSingleton<IInventoryService, InventoryService>();
-builder.Services.AddSingleton<IMovieEndpoints, MovieEndpoints>();
+builder.Services.AddSingleton<IStreamingService, StreamingService>();
 builder.Services.AddSingleton<IMetadataAPI, OMDbAPI>();
+builder.Services.AddSingleton<IApiEndpoints, ApiEndpoints>();
+builder.Services.AddSingleton<IStreamingEndpoints, StreamingEndpoints>();
 
 builder.Services.AddHttpClient<IMetadataAPI, OMDbAPI>();
 
 var app = builder.Build();
 
-
 app.UseSwagger();
 app.UseSwaggerUI();
 
-
 app.UseHttpsRedirection();
 
-
 var contentDiscoveryService = app.Services.GetService<IContentDiscoveryService>();
 contentDiscoveryService?.ActiveScan(Globals.MediaFolder);
 contentDiscoveryService?.Watch(Globals.MediaFolder);
 
-var movieEndpoints = app.Services.GetService<IMovieEndpoints>();
-movieEndpoints?.Map(app);
+app.Services.GetService<IApiEndpoints>()?.Map(app);
+app.Services.GetService<IStreamingEndpoints>()?.Map(app);
 
 app.Run();

OpenMediaServer/Services/InventoryService.cs

@@ -21,6 +21,21 @@ public InventoryService(ILogger<InventoryService> logger, IStorageRepository sto
         _configuration = configuration;
     }
 
+    public async Task<IEnumerable<string>> ListCategories()
+    {
+        return new List<string> {  }; // TODO Implement
+    }
+
+    public async Task<IEnumerable<InventoryItem>> ListItems(string category)
+    {
+        return new List<InventoryItem> {  }; // TODO Implement
+    }
+
+    public async Task<InventoryItem> GetItem(string id, string category)
+    {
+        return new InventoryItem(); // TODO Implement
+    }
+
     public async void CreateFromPaths(IEnumerable<string> paths)
     {
         foreach (var path in paths)

OpenMediaServer/Services/StreamingService.cs

@@ -0,0 +1,21 @@
+using System;
+using OpenMediaServer.Interfaces.Services;
+
+namespace OpenMediaServer.Services;
+
+public class StreamingService : IStreamingService
+{
+    private readonly ILogger<StreamingService> _logger;
+
+    public StreamingService(ILogger<StreamingService> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<Stream> GetMediaStream(string id, string category)
+    {
+        // TODO Implement
+
+        throw new NotImplementedException();
+    }
+}