Merge beta into refactored code

.gitignore

@@ -364,6 +364,7 @@ FodyWeavers.xsd
 
 # MediathekArr specifics
 config.json
+mediathekarr.json
 *.mp4
 *.mkv
 ffmpeg/

Dockerfile

@@ -23,6 +23,7 @@ RUN apt-get update && apt-get install -y \
     gosu \
     wget \
     gnupg \
+    ffmpeg \
     && rm -rf /var/lib/apt/lists/*
 
 # Add MKVToolNix repository and install

Dockerfile.arm64

@@ -0,0 +1,53 @@
+FROM --platform=linux/arm64 mcr.microsoft.com/dotnet/sdk:9.0 AS build-env
+WORKDIR /app
+
+# Copy and restore dependencies
+COPY . ./
+RUN dotnet restore
+
+# Publish MediathekArrServer
+WORKDIR /app/MediathekArrServer
+RUN dotnet publish -c Release -o /app/out/MediathekArrServer
+
+# Publish MediathekArrDownloader
+WORKDIR /app/MediathekArr
+RUN dotnet publish -c Release -o /app/out/MediathekArrDownloader
+
+# Final runtime image
+FROM --platform=linux/arm64 mcr.microsoft.com/dotnet/aspnet:9.0
+
+# Install required packages
+RUN apt-get update && apt-get install -y \
+    tar \
+    xz-utils \
+    gosu \
+    wget \
+    gnupg \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Add MKVToolNix repository and install
+RUN wget -O /etc/apt/keyrings/gpg-pub-moritzbunkus.gpg https://mkvtoolnix.download/gpg-pub-moritzbunkus.gpg && \
+    echo "deb [signed-by=/etc/apt/keyrings/gpg-pub-moritzbunkus.gpg] https://mkvtoolnix.download/debian/ bookworm main" > /etc/apt/sources.list.d/mkvtoolnix.download.list && \
+    apt-get update && apt-get install -y \
+    mkvtoolnix
+
+# Set working directory
+WORKDIR /app
+
+# Copy the built apps from the build environment
+COPY --from=build-env /app/out/MediathekArrServer /app/MediathekArrServer
+COPY --from=build-env /app/out/MediathekArrDownloader /app/MediathekArrDownloader
+
+# Copy the startup script
+COPY docker_start.sh /app/docker_start.sh
+RUN chmod +x /app/docker_start.sh
+
+# Create required directories
+RUN mkdir -p /data/mediathek/incomplete /data/mediathek/complete
+
+ENV ASPNETCORE_ENVIRONMENT=Production
+ENV CONFIG_PATH=/app/config
+
+# Use the shell script to start both processes
+ENTRYPOINT ["/app/docker_start.sh"]

MediathekArr/Controllers/ApiProxyControllerBase.cs

@@ -0,0 +1,157 @@
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Net;
+
+namespace MediathekArr.Controllers;
+
+public abstract class ApiProxyControllerBase : ControllerBase
+{
+    protected readonly IHttpClientFactory HttpClientFactory;
+
+    protected ApiProxyControllerBase(IHttpClientFactory httpClientFactory)
+    {
+        HttpClientFactory = httpClientFactory;
+    }
+
+    protected IActionResult? ValidateRequiredParameters(string apiKey, string host, string hostName = "Host")
+    {
+        if (string.IsNullOrWhiteSpace(apiKey) || string.IsNullOrWhiteSpace(host))
+        {
+            return BadRequest($"{hostName} and API key are required.");
+        }
+        return null;
+    }
+
+    protected HttpClient CreateHttpClient(string apiKey)
+    {
+        var httpClient = HttpClientFactory.CreateClient();
+        httpClient.DefaultRequestHeaders.Add("X-Api-Key", apiKey);
+        return httpClient;
+    }
+
+    protected async Task<string> ReadRequestBodyAsync()
+    {
+        using var reader = new StreamReader(Request.Body);
+        return await reader.ReadToEndAsync();
+    }
+
+    protected IActionResult HandleErrorResponse(HttpStatusCode statusCode, string responseContent, string errorContext)
+    {
+        string message = $"Error {errorContext}";
+
+        if (!string.IsNullOrWhiteSpace(responseContent))
+        {
+            try
+            {
+                // Try to parse as array of validation errors
+                var errorArray = JsonConvert.DeserializeObject<List<JObject>>(responseContent);
+                if (errorArray?.Count > 0)
+                {
+                    var errorMessages = errorArray
+                        .Select(err => (string)err["errorMessage"])
+                        .Where(msg => !string.IsNullOrEmpty(msg))
+                        .ToList();
+
+                    if (errorMessages.Count != 0)
+                    {
+                        message = string.Join(", ", errorMessages);
+                        var propertyName = errorArray.Select(err => (string)err["propertyName"]).FirstOrDefault();
+                        var attemptedValue = errorArray.Select(err => (string)err["attemptedValue"]).FirstOrDefault();
+                        if (propertyName is not null)
+                        {
+                            message += $":{Environment.NewLine}Property Name: \"{propertyName}\"{Environment.NewLine}Attempted Value: \"{attemptedValue}\"";
+                        }
+                    }
+                }
+                else
+                {
+                    // Try to parse as a single error object with errorMessage property
+                    var errorObj = JsonConvert.DeserializeObject<JObject>(responseContent);
+                    if (errorObj?["errorMessage"] != null)
+                    {
+                        message = errorObj["errorMessage"].ToString();
+                    }
+                }
+            }
+            catch
+            {
+                // If parsing fails, fall back to raw response content
+                message = responseContent;
+            }
+        }
+
+        var errorResult = new
+        {
+            error = new
+            {
+                message
+            }
+        };
+
+        return StatusCode((int)statusCode, errorResult);
+    }
+
+
+    protected async Task<IActionResult> ExecuteApiRequest(
+        string apiKey,
+        string host,
+        string endpoint,
+        HttpMethod method,
+        string errorContext,
+        Func<string, IActionResult> processSuccessResponse = null,
+        string hostName = "Host",
+        bool isProwlarr = false)
+    {
+        var validationResult = ValidateRequiredParameters(apiKey, host, hostName);
+        if (validationResult != null)
+            return validationResult;
+
+        var cleanedHostName = host.TrimEnd('/');
+        var httpClient = CreateHttpClient(apiKey);
+
+        try
+        {
+            StringContent content = null;
+
+            if (method != HttpMethod.Get)
+            {
+                var rawBody = await ReadRequestBodyAsync();
+                content = new StringContent(rawBody, System.Text.Encoding.UTF8, "application/json");
+            }
+
+            HttpResponseMessage response;
+
+            if (method == HttpMethod.Get)
+            {
+                response = await httpClient.GetAsync($"{cleanedHostName}/{endpoint}");
+            }
+            else if (method == HttpMethod.Post)
+            {
+                response = await httpClient.PostAsync($"{cleanedHostName}/{endpoint}", content);
+            }
+            else // PUT
+            {
+                response = await httpClient.PutAsync($"{cleanedHostName}/{endpoint}", content);
+            }
+
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!response.IsSuccessStatusCode)
+            {
+                return HandleErrorResponse(response.StatusCode, responseContent, errorContext);
+            }
+
+            if (processSuccessResponse != null)
+            {
+                return processSuccessResponse(responseContent);
+            }
+
+            return Content(responseContent, "application/json");
+        }
+        catch (Exception ex)
+        {
+            return StatusCode(500, $"Error {errorContext}: {ex.Message}");
+        }
+    }
+}

MediathekArr/Controllers/DownloadController.Config.cs

@@ -1,7 +1,7 @@
-using MediathekArrDownloader.Models;
+using MediathekArr.Models;
 using Microsoft.AspNetCore.Mvc;
 
-namespace MediathekArrDownloader.Controllers;
+namespace MediathekArr.Controllers;
 
 public partial class DownloadController
 {
@@ -10,14 +10,27 @@ public IActionResult GetConfig()
     {
         var incompleteEnv = Environment.GetEnvironmentVariable("DOWNLOAD_INCOMPLETE_PATH");
         var completeEnv = Environment.GetEnvironmentVariable("DOWNLOAD_COMPLETE_PATH");
-
+        var categoriesEnv = Environment.GetEnvironmentVariable("CATEGORIES");
+        var maxParallelDownloadsEnv = Environment.GetEnvironmentVariable("MAX_PARALLEL_DOWNLOADS");
+
+        // Parse categories from environment variable if present
+        if (!string.IsNullOrEmpty(categoriesEnv))
+        {
+            _config.Categories = categoriesEnv.Split(',')
+                .Select(c => c.Trim())
+                .Where(c => !string.IsNullOrEmpty(c))
+                .ToArray();
+        }
+
         var configDetails = new
         {
             config = _config,
             overrides = new
             {
                 IncompletePath = !string.IsNullOrEmpty(incompleteEnv),
-                CompletePath = !string.IsNullOrEmpty(completeEnv)
+                CompletePath = !string.IsNullOrEmpty(completeEnv),
+                Categories = !string.IsNullOrEmpty(categoriesEnv),
+                MaxParallelDownloads = !string.IsNullOrEmpty(maxParallelDownloadsEnv)
             }
         };
 
@@ -29,6 +42,10 @@ public IActionResult UpdateConfig([FromBody] Config newConfig)
     {
         var incompleteEnv = Environment.GetEnvironmentVariable("DOWNLOAD_INCOMPLETE_PATH");
         var completeEnv = Environment.GetEnvironmentVariable("DOWNLOAD_COMPLETE_PATH");
+        var categoriesEnv = Environment.GetEnvironmentVariable("CATEGORIES");
+        var maxParallelDownloadsEnv = Environment.GetEnvironmentVariable("MAX_PARALLEL_DOWNLOADS");
+
+        bool requiresRestart = false;
 
         // Prevent updates to fields overridden by environment variables
         if (string.IsNullOrEmpty(incompleteEnv))
@@ -41,6 +58,27 @@ public IActionResult UpdateConfig([FromBody] Config newConfig)
             _config.CompletePath = newConfig.CompletePath;
         }
 
+        // Only update categories if not overridden by environment variable
+        if (string.IsNullOrEmpty(categoriesEnv))
+        {
+            if (_config.Categories != newConfig.Categories)
+            {
+                _config.Categories = newConfig.Categories;
+
+                // Create directories for each category
+                _downloadService.InitializeCompleteDirectories();
+            }
+        }
+
+        if (string.IsNullOrEmpty(maxParallelDownloadsEnv))
+        {
+            if (_config.MaxParallelDownloads != newConfig.MaxParallelDownloads)
+            {
+                _config.MaxParallelDownloads = Math.Clamp(newConfig.MaxParallelDownloads, 1, 10);
+                requiresRestart = true;
+            }
+        }
+
         // Persist updated config to file
         var configPathEnv = Environment.GetEnvironmentVariable("CONFIG_PATH");
 
@@ -59,9 +97,10 @@ public IActionResult UpdateConfig([FromBody] Config newConfig)
         }
         System.IO.File.WriteAllText(configFilePath, System.Text.Json.JsonSerializer.Serialize(_config, new System.Text.Json.JsonSerializerOptions { WriteIndented = true }));
 
-        return Ok(new { status = "success" });
+        return Ok(new { status = "success", requiresRestart });
     }
 
+
     [HttpGet("browse")]
     public IActionResult BrowsePath([FromQuery] string path = "")
     {