CUB-33: Integrate Moonraker filament usage polling with UsageLog persistence

backend/API/Jobs/FilamentUsageSyncJob.cs

@@ -1,5 +1,6 @@
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -15,25 +16,30 @@ namespace Extrudex.API.Jobs;
 /// Configuration is bound from the "FilamentUsageSync" section in
 /// appsettings.json. Set Enabled=false to disable without removing
 /// the service registration.
+/// 
+/// Uses an IServiceScopeFactory to resolve scoped dependencies
+/// (IFilamentUsageSyncService, IUsageLogService) on each sync cycle,
+/// avoiding captive-dependency issues from injecting scoped services
+/// into the singleton BackgroundService lifetime.
 /// </summary>
 public class FilamentUsageSyncJob : BackgroundService
 {
-    private readonly IFilamentUsageSyncService _syncService;
+    private readonly IServiceScopeFactory _scopeFactory;
     private readonly FilamentUsageSyncOptions _options;
     private readonly ILogger<FilamentUsageSyncJob> _logger;
 
     /// <summary>
     /// Creates a new FilamentUsageSyncJob.
     /// </summary>
-    /// <param name="syncService">The service that performs the actual sync logic.</param>
+    /// <param name="scopeFactory">Factory for creating DI scopes to resolve scoped services.</param>
     /// <param name="options">Configuration options for polling interval and timeouts.</param>
     /// <param name="logger">Logger for diagnostic output.</param>
     public FilamentUsageSyncJob(
-        IFilamentUsageSyncService syncService,
+        IServiceScopeFactory scopeFactory,
         IOptions<FilamentUsageSyncOptions> options,
         ILogger<FilamentUsageSyncJob> logger)
     {
-        _syncService = syncService;
+        _scopeFactory = scopeFactory;
         _options = options.Value;
         _logger = logger;
     }
@@ -58,7 +64,9 @@ public class FilamentUsageSyncJob : BackgroundService
         {
             try
                        {
-                var syncedCount = await _syncService.SyncAllAsync(stoppingToken);
+                using var scope = _scopeFactory.CreateScope();
+                var syncService = scope.ServiceProvider.GetRequiredService<IFilamentUsageSyncService>();
+                var syncedCount = await syncService.SyncAllAsync(stoppingToken);
 
                 _logger.LogInformation(
                     "Filament usage sync completed — {SyncedCount} printer(s) synced. Next sync in {Interval}",

backend/API/Jobs/MoonrakerPrinterSyncJob.cs

@@ -1,5 +1,6 @@
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -19,22 +20,22 @@ namespace Extrudex.API.Jobs;
 /// </summary>
 public class MoonrakerPrinterSyncJob : BackgroundService
 {
-    private readonly IMoonrakerPrinterSyncService _syncService;
+    private readonly IServiceScopeFactory _scopeFactory;
     private readonly MoonrakerPrinterSyncOptions _options;
     private readonly ILogger<MoonrakerPrinterSyncJob> _logger;
 
     /// <summary>
     /// Creates a new MoonrakerPrinterSyncJob.
     /// </summary>
-    /// <param name="syncService">The service that performs the actual sync logic.</param>
+    /// <param name="scopeFactory">Factory for creating DI scopes to resolve scoped services.</param>
     /// <param name="options">Configuration options for polling interval and timeouts.</param>
     /// <param name="logger">Logger for diagnostic output.</param>
     public MoonrakerPrinterSyncJob(
-        IMoonrakerPrinterSyncService syncService,
+        IServiceScopeFactory scopeFactory,
         IOptions<MoonrakerPrinterSyncOptions> options,
         ILogger<MoonrakerPrinterSyncJob> logger)
     {
-        _syncService = syncService;
+        _scopeFactory = scopeFactory;
         _options = options.Value;
         _logger = logger;
     }
@@ -59,7 +60,9 @@ public class MoonrakerPrinterSyncJob : BackgroundService
         {
             try
             {
-                var syncedCount = await _syncService.SyncAllAsync(stoppingToken);
+                using var scope = _scopeFactory.CreateScope();
+                var syncService = scope.ServiceProvider.GetRequiredService<IMoonrakerPrinterSyncService>();
+                var syncedCount = await syncService.SyncAllAsync(stoppingToken);
 
                 _logger.LogInformation(
                     "Moonraker printer sync completed — {SyncedCount} printer(s) synced. Next sync in {Interval}",

backend/Dockerfile

@@ -1,25 +1,37 @@
-# Build stage
-FROM golang:1.24-alpine AS builder
+# ── Stage 1: Build ──────────────────────────────────────────
+FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
+WORKDIR /src
 
+# Copy csproj first for layer caching — restores before copying source
+COPY Extrudex.csproj .
+RUN dotnet restore
+
+# Copy the rest of the source
+COPY . .
+RUN dotnet publish Extrudex.csproj \
+    -c Release \
+    -o /app/publish \
+    --no-restore
+
+# ── Stage 2: Runtime ────────────────────────────────────────
+FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS runtime
 WORKDIR /app
 
-# Copy go mod files first for caching
-COPY go.mod go.sum ./
-RUN go mod download
+# Install curl for health check (not included in aspnet base image)
+RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
 
-# Copy source and build
-COPY . .
-RUN CGO_ENABLED=0 GOOS=linux go build -o server ./cmd/server
+# Non-root user for security
+RUN adduser --disabled-password --gecos "" appuser
+USER appuser
 
-# Final stage
-FROM alpine:latest
-RUN apk --no-cache add ca-certificates
-
-WORKDIR /root/
-
-# Copy binary from builder
-COPY --from=builder /app/server .
+# Copy published output from build stage
+COPY --from=build /app/publish .
 
+# ASP.NET Core listens on 8080 by default in .NET 8+
 EXPOSE 8080
 
-CMD ["./server"]
+# Health check against /health endpoint
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD curl --fail http://localhost:8080/health || exit 1
+
+ENTRYPOINT ["dotnet", "Extrudex.dll"]

backend/Domain/Interfaces/IFilamentUsageService.cs

@@ -1,50 +0,0 @@
-using Extrudex.Domain.Entities;
-
-namespace Extrudex.Domain.Interfaces;
-
-/// <summary>
-/// Service for persisting and querying filament usage records.
-/// Tracks consumption per print job and per spool for COGS and inventory tracking.
-/// </summary>
-public interface IFilamentUsageService
-{
-    /// <summary>
-    /// Records a new filament usage entry for a print job.
-    /// </summary>
-    /// <param name="printJobId">The print job that consumed the filament.</param>
-    /// <param name="spoolId">The spool that provided the filament.</param>
-    /// <param name="printerId">The printer that executed the print.</param>
-    /// <param name="gramsUsed">Grams of filament consumed.</param>
-    /// <param name="mmExtruded">Millimeters of filament extruded.</param>
-    /// <param name="notes">Optional notes about this usage record.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    /// <returns>The created FilamentUsage entity.</returns>
-    Task<FilamentUsage> RecordUsageAsync(
-        Guid printJobId,
-        Guid spoolId,
-        Guid printerId,
-        decimal gramsUsed,
-        decimal mmExtruded,
-        string? notes = null,
-        CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Retrieves all filament usage records for a specific print job.
-    /// </summary>
-    /// <param name="printJobId">The print job ID.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    /// <returns>Collection of filament usage records for the print job.</returns>
-    Task<IReadOnlyList<FilamentUsage>> GetByPrintJobAsync(
-        Guid printJobId,
-        CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Retrieves all filament usage records for a specific spool.
-    /// </summary>
-    /// <param name="spoolId">The spool ID.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    /// <returns>Collection of filament usage records for the spool.</returns>
-    Task<IReadOnlyList<FilamentUsage>> GetBySpoolAsync(
-        Guid spoolId,
-        CancellationToken cancellationToken = default);
-}

backend/Infrastructure/Services/FilamentUsageService.cs

@@ -1,79 +0,0 @@
-using Extrudex.Domain.Entities;
-using Extrudex.Domain.Interfaces;
-using Extrudex.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-
-namespace Extrudex.Infrastructure.Services;
-
-/// <summary>
-/// EF Core–backed implementation of the filament usage service.
-/// Persists usage records to the database and provides query methods
-/// for retrieving usage by print job or spool.
-/// </summary>
-public class FilamentUsageService : IFilamentUsageService
-{
-    private readonly ExtrudexDbContext _dbContext;
-    private readonly ILogger<FilamentUsageService> _logger;
-
-    public FilamentUsageService(
-        ExtrudexDbContext dbContext,
-        ILogger<FilamentUsageService> logger)
-    {
-        _dbContext = dbContext;
-        _logger = logger;
-    }
-
-    /// <inheritdoc />
-    public async Task<FilamentUsage> RecordUsageAsync(
-        Guid printJobId,
-        Guid spoolId,
-        Guid printerId,
-        decimal gramsUsed,
-        decimal mmExtruded,
-        string? notes = null,
-        CancellationToken cancellationToken = default)
-    {
-        var usage = new FilamentUsage
-        {
-            PrintJobId = printJobId,
-            SpoolId = spoolId,
-            PrinterId = printerId,
-            GramsUsed = gramsUsed,
-            MmExtruded = mmExtruded,
-            RecordedAt = DateTime.UtcNow,
-            Notes = notes
-        };
-
-        _dbContext.FilamentUsages.Add(usage);
-        await _dbContext.SaveChangesAsync(cancellationToken);
-
-        _logger.LogInformation(
-            "Recorded filament usage: {Grams}g / {Mm}mm for print job {JobId} on spool {SpoolId}",
-            gramsUsed, mmExtruded, printJobId, spoolId);
-
-        return usage;
-    }
-
-    /// <inheritdoc />
-    public async Task<IReadOnlyList<FilamentUsage>> GetByPrintJobAsync(
-        Guid printJobId,
-        CancellationToken cancellationToken = default)
-    {
-        return await _dbContext.FilamentUsages
-            .Where(u => u.PrintJobId == printJobId)
-            .OrderByDescending(u => u.RecordedAt)
-            .ToListAsync(cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public async Task<IReadOnlyList<FilamentUsage>> GetBySpoolAsync(
-        Guid spoolId,
-        CancellationToken cancellationToken = default)
-    {
-        return await _dbContext.FilamentUsages
-            .Where(u => u.SpoolId == spoolId)
-            .OrderByDescending(u => u.RecordedAt)
-            .ToListAsync(cancellationToken);
-    }
-}

backend/Infrastructure/Services/FilamentUsageSyncService.cs

@@ -1,21 +1,24 @@
+using Extrudex.Domain.DTOs.Moonraker;
+using Extrudex.Domain.Entities;
 using Extrudex.Domain.Enums;
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 
-namespace Extrudex.Infrastructure.Configuration;
+namespace Extrudex.Infrastructure.Services;
 
 /// <summary>
 /// Service that syncs filament usage data from Moonraker printers into the
 /// Extrudex database. Queries all active Moonraker printers, fetches their
-/// current filament usage metrics, and updates spool remaining weights and
-/// print job records.
+/// current filament usage metrics, persists usage entries to the UsageLog table,
+/// creates FilamentUsage records for completed jobs, and updates spool remaining weights.
 /// </summary>
 public class FilamentUsageSyncService : IFilamentUsageSyncService
 {
     private readonly ExtrudexDbContext _dbContext;
     private readonly IMoonrakerClient _moonrakerClient;
+    private readonly IUsageLogService _usageLogService;
     private readonly ILogger<FilamentUsageSyncService> _logger;
 
     /// <summary>
@@ -23,14 +26,17 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
     /// </summary>
     /// <param name="dbContext">The EF Core database context for persisting updates.</param>
     /// <param name="moonrakerClient">The Moonraker HTTP client for fetching printer data.</param>
+    /// <param name="usageLogService">The usage log service for persisting usage entries.</param>
     /// <param name="logger">Logger for diagnostic output.</param>
     public FilamentUsageSyncService(
         ExtrudexDbContext dbContext,
         IMoonrakerClient moonrakerClient,
+        IUsageLogService usageLogService,
         ILogger<FilamentUsageSyncService> logger)
     {
         _dbContext = dbContext;
         _moonrakerClient = moonrakerClient;
+        _usageLogService = usageLogService;
         _logger = logger;
     }
 
@@ -43,7 +49,9 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
             .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
             .Include(p => p.AmsUnits)
                 .ThenInclude(u => u.Slots)
-                    .ThenInclude(s => s.Spool)
+                    .ThenInclude(s => s.Spool!)
+                        .ThenInclude(s => s.MaterialBase)
+            .Include(p => p.PrintJobs)
             .ToListAsync(cancellationToken);
 
         if (printers.Count == 0)
@@ -60,33 +68,18 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
         {
             try
             {
-                var usageData = await _moonrakerClient.GetFilamentUsageAsync(
-                    printer.HostnameOrIp,
-                    printer.Port,
-                    printer.ApiKey,
-                    cancellationToken);
-
-                if (usageData.Count == 0)
-                {
-                    _logger.LogWarning(
-                        "No usage data returned from printer {PrinterName} ({Host}:{Port})",
-                        printer.Name, printer.HostnameOrIp, printer.Port);
-                    continue;
-                }
-
-                // Update spool remaining weights from AMS data
-                UpdateSpoolWeights(printer, usageData);
-
-                // Mark printer as seen and idle (reachable = idle, not printing)
-                printer.LastSeenAt = DateTime.UtcNow;
-                printer.Status = PrinterStatus.Idle;
-
+                await SyncPrinterAsync(printer, cancellationToken);
                 syncedCount++;
-                _logger.LogInformation(
-                    "Successfully synced filament usage from printer {PrinterName}",
-                    printer.Name);
             }
-            catch (Exception ex)
+            catch (HttpRequestException ex)
+            {
+                _logger.LogError(ex,
+                    "Connection error syncing filament usage from printer {PrinterName} ({Host}:{Port}) — printer may be offline",
+                    printer.Name, printer.HostnameOrIp, printer.Port);
+
+                printer.Status = PrinterStatus.Offline;
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
             {
                 _logger.LogError(ex,
                     "Error syncing filament usage from printer {PrinterName} ({Host}:{Port})",
@@ -103,12 +96,168 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
         return syncedCount;
     }
 
+    /// <summary>
+    /// Syncs a single Moonraker printer: fetches print stats and history,
+    /// persists usage data to UsageLog and FilamentUsage tables, and
+    /// updates spool remaining weights.
+    /// </summary>
+    private async Task SyncPrinterAsync(Printer printer, CancellationToken cancellationToken)
+    {
+        // Step 1: Fetch current print stats for real-time filament usage
+        var printStats = await _moonrakerClient.GetPrintStatsAsync(
+            printer.HostnameOrIp, printer.Port, printer.ApiKey, cancellationToken);
+
+        // Step 2: Fetch usage dictionary for backward-compatible metrics
+        var usageData = await _moonrakerClient.GetFilamentUsageAsync(
+            printer.HostnameOrIp, printer.Port, printer.ApiKey, cancellationToken);
+
+        // Step 3: Update printer status based on print stats
+        if (printStats != null)
+        {
+            printer.Status = printStats.State.ToLowerInvariant() switch
+            {
+                "printing" => PrinterStatus.Printing,
+                "paused" => PrinterStatus.Paused,
+                "complete" => PrinterStatus.Idle,
+                "standby" => PrinterStatus.Idle,
+                "cancelled" => PrinterStatus.Idle,
+                "error" => PrinterStatus.Error,
+                _ => printer.Status
+            };
+        }
+
+        printer.LastSeenAt = DateTime.UtcNow;
+
+        // Step 4: Update spool remaining weights from AMS data
+        UpdateSpoolWeights(printer, usageData);
+
+        // Step 5: If there's filament usage from print stats, persist it
+        if (printStats != null && printStats.FilamentUsedMm > 0)
+        {
+            await PersistFilamentUsageAsync(printer, printStats, cancellationToken);
+        }
+        else if (usageData.TryGetValue("mm_extruded", out var mmExtruded) && mmExtruded > 0)
+        {
+            // Fall back to dictionary metrics if print stats aren't available
+            _logger.LogInformation(
+                "Printer {PrinterName} reports {MmExtruded}mm filament extruded in latest job (from usage dictionary)",
+                printer.Name, mmExtruded);
+        }
+
+        _logger.LogInformation(
+            "Successfully synced filament usage from printer {PrinterName}",
+            printer.Name);
+    }
+
+    /// <summary>
+    /// Persists filament usage data from print stats to the database.
+    /// Creates a FilamentUsage record and a UsageLog entry, and deducts
+    /// consumed grams from the spool's remaining weight.
+    /// </summary>
+    private async Task PersistFilamentUsageAsync(
+        Printer printer,
+        MoonrakerPrintStats printStats,
+        CancellationToken cancellationToken)
+    {
+        // Find the default spool for this printer
+        var defaultSpool = FindDefaultSpool(printer);
+
+        if (defaultSpool == null)
+        {
+            _logger.LogWarning(
+                "No default spool found for printer {PrinterName} — cannot persist filament usage of {MmExtruded}mm",
+                printer.Name, printStats.FilamentUsedMm);
+            return;
+        }
+
+        // Calculate derived grams
+        var gramsDerived = CalculateGrams(
+            printStats.FilamentUsedMm,
+            defaultSpool.FilamentDiameterMm,
+            defaultSpool.MaterialBase.DensityGperCm3);
+
+        if (gramsDerived <= 0)
+        {
+            _logger.LogDebug(
+                "No grams derived for printer {PrinterName} — skipping usage persistence",
+                printer.Name);
+            return;
+        }
+
+        // Deduct from spool remaining weight (floor at 0)
+        var previousWeight = defaultSpool.WeightRemainingGrams;
+        defaultSpool.WeightRemainingGrams = Math.Max(0, defaultSpool.WeightRemainingGrams - gramsDerived);
+
+        _logger.LogInformation(
+            "Deducted {Grams:F1}g from spool {SpoolSerial} (was {Previous:F1}g, now {Current:F1}g) for printer {PrinterName}",
+            gramsDerived, defaultSpool.SpoolSerial, previousWeight, defaultSpool.WeightRemainingGrams, printer.Name);
+
+        // Check if we already have a recent FilamentUsage for this printer
+        // to avoid double-counting on repeated poll cycles for the same job
+        var recentUsageThreshold = DateTime.UtcNow.AddMinutes(-10);
+        var existingRecentUsage = await _dbContext.FilamentUsages
+            .Where(fu => fu.PrinterId == printer.Id && fu.RecordedAt >= recentUsageThreshold)
+            .AnyAsync(cancellationToken);
+
+        if (existingRecentUsage)
+        {
+            _logger.LogDebug(
+                "Recent FilamentUsage record exists for printer {PrinterName} — skipping to avoid double-counting",
+                printer.Name);
+            return;
+        }
+
+        // Create a FilamentUsage entity for the consumption
+        var filamentUsage = new FilamentUsage
+        {
+            SpoolId = defaultSpool.Id,
+            PrinterId = printer.Id,
+            GramsUsed = gramsDerived,
+            MmExtruded = printStats.FilamentUsedMm,
+            RecordedAt = DateTime.UtcNow,
+            Notes = $"Auto-recorded from Moonraker print stats (state: {printStats.State})"
+        };
+
+        // If there's a matching print job, link it
+        var matchingJob = FindMatchingPrintJob(printer, printStats);
+        if (matchingJob != null)
+        {
+            filamentUsage.PrintJobId = matchingJob.Id;
+            filamentUsage.PrintJob = matchingJob;
+        }
+
+        _dbContext.FilamentUsages.Add(filamentUsage);
+
+        // Also persist to UsageLog via the usage logging service
+        try
+        {
+            await _usageLogService.RecordUsageAsync(
+                spoolId: defaultSpool.Id,
+                gramsUsed: gramsDerived,
+                dataSource: DataSource.Moonraker,
+                printerId: printer.Id,
+                printJobId: matchingJob?.Id,
+                mmExtruded: printStats.FilamentUsedMm,
+                notes: $"Auto-recorded from Moonraker print stats (state: {printStats.State})");
+
+            _logger.LogInformation(
+                "Persisted usage log: {Grams:F1}g / {Mm:F1}mm for spool {SpoolSerial} on printer {PrinterName}",
+                gramsDerived, printStats.FilamentUsedMm, defaultSpool.SpoolSerial, printer.Name);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex,
+                "Failed to persist usage log for printer {PrinterName} — FilamentUsage entity was still created",
+                printer.Name);
+        }
+    }
+
     /// <summary>
     /// Updates spool remaining weights based on usage data received from Moonraker.
     /// For printers with AMS units, updates the remaining weight on each slot's spool.
     /// </summary>
     private void UpdateSpoolWeights(
-        Domain.Entities.Printer printer,
+        Printer printer,
         Dictionary<string, decimal> usageData)
     {
         // Update AMS slot remaining weights if available
@@ -122,7 +271,7 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
                     slot.Spool.WeightRemainingGrams = slot.RemainingWeightG.Value;
 
                     _logger.LogDebug(
-                        "Updated spool {SpoolSerial} remaining weight to {Weight}g",
+                        "Updated spool {SpoolSerial} remaining weight to {Weight}g from AMS data",
                         slot.Spool.SpoolSerial, slot.RemainingWeightG.Value);
                 }
             }
@@ -136,4 +285,56 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
                 printer.Name, mmExtruded);
         }
     }
+
+    /// <summary>
+    /// Finds the default spool for a printer. Returns the first active, non-archived spool
+    /// loaded in an AMS slot, or null if no spool is available.
+    /// </summary>
+    private static Spool? FindDefaultSpool(Printer printer)
+    {
+        foreach (var amsUnit in printer.AmsUnits)
+        {
+            foreach (var slot in amsUnit.Slots)
+            {
+                if (slot.Spool != null && slot.Spool.IsActive && !slot.Spool.IsArchived)
+                {
+                    return slot.Spool;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Finds a PrintJob on this printer that matches the current print stats.
+    /// Matches by filename and non-completed status to avoid double-linking.
+    /// </summary>
+    private PrintJob? FindMatchingPrintJob(Printer printer, MoonrakerPrintStats printStats)
+    {
+        if (string.IsNullOrEmpty(printStats.Filename))
+            return null;
+
+        return printer.PrintJobs
+            .FirstOrDefault(pj => pj.PrintName == printStats.Filename
+                && pj.Status != JobStatus.Completed
+                && pj.Status != JobStatus.Cancelled);
+    }
+
+    /// <summary>
+    /// Calculates derived grams from millimeters extruded using the standard formula:
+    /// grams = mm_extruded × cross_section_area × material_density
+    /// where cross_section_area = π × (diameter / 2)²
+    /// </summary>
+    private static decimal CalculateGrams(decimal mmExtruded, decimal diameterMm, decimal densityGperCm3)
+    {
+        if (mmExtruded <= 0) return 0m;
+
+        var radiusCm = (double)diameterMm / 2.0 / 10.0; // mm to cm
+        var crossSectionAreaCm2 = Math.PI * radiusCm * radiusCm;
+        var mmToCm = (double)mmExtruded / 10.0;
+
+        var grams = mmToCm * crossSectionAreaCm2 * (double)densityGperCm3;
+        return (decimal)grams;
+    }
 }

backend/Infrastructure/Services/MoonrakerPrinterSyncService.cs

@@ -46,7 +46,7 @@ public class MoonrakerPrinterSyncService : IMoonrakerPrinterSyncService
             .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
             .Include(p => p.AmsUnits)
                 .ThenInclude(u => u.Slots)
-                    .ThenInclude(s => s.Spool)
+                    .ThenInclude(s => s.Spool!)
                         .ThenInclude(s => s.MaterialBase)
             .Include(p => p.PrintJobs)
             .ToListAsync(cancellationToken);

backend/Infrastructure/Services/MoonrakerUsagePoller.cs

@@ -1,390 +0,0 @@
-using Extrudex.Domain.DTOs.Moonraker;
-using Extrudex.Domain.Entities;
-using Extrudex.Domain.Enums;
-using Extrudex.Domain.Interfaces;
-using Extrudex.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Extrudex.Infrastructure.Services;
-
-/// <summary>
-/// Configuration options for the Moonraker usage polling service.
-/// </summary>
-public class MoonrakerPollerOptions
-{
-    /// <summary>
-    /// How often to poll each Moonraker printer for filament usage data.
-    /// Default: 30 seconds.
-    /// </summary>
-    public TimeSpan PollInterval { get; set; } = TimeSpan.FromSeconds(30);
-
-    /// <summary>
-    /// Timeout for individual Moonraker HTTP requests.
-    /// Default: 10 seconds.
-    /// </summary>
-    public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(10);
-
-    /// <summary>
-    /// Whether the polling service is enabled. Default: true.
-    /// Set to false to disable polling (e.g., in development or testing).
-    /// </summary>
-    public bool Enabled { get; set; } = true;
-}
-
-/// <summary>
-/// Background service that periodically polls Moonraker-connected printers
-/// for filament usage data. When a print job is detected as complete,
-/// the usage data is persisted to the FilamentUsage table via
-/// <see cref="IFilamentUsageService"/>.
-///
-/// <para>Polling logic:</para>
-/// <list type="number">
-///   <item>Query the database for all active printers with ConnectionType == Moonraker.</item>
-///   <item>For each printer, call <see cref="IMoonrakerClient.GetPrintStatsAsync"/> for live data
-///         and <see cref="IMoonrakerClient.GetPrintHistoryAsync"/> for completed job history.</item>
-///   <item>If usage data is available and the print state is "complete",
-///         create or update a FilamentUsage record.</item>
-///   <item>If the printer is unreachable or returns malformed data, log a warning
-///         and continue to the next printer (no crash).</item>
-/// </list>
-///
-/// <para>Error handling:</para>
-/// <list type="bullet">
-///   <item>API unreachable: logged as warning, poller continues for other printers.</item>
-///   <item>Malformed response: logged as warning, poller continues.</item>
-///   <item>Database errors: logged as error, poller continues.</item>
-/// </list>
-/// </summary>
-public class MoonrakerUsagePoller : BackgroundService
-{
-    private readonly IServiceScopeFactory _scopeFactory;
-    private readonly ILogger<MoonrakerUsagePoller> _logger;
-    private readonly MoonrakerPollerOptions _options;
-
-    /// <summary>
-    /// Tracks which Moonraker print jobs have already been recorded,
-    /// keyed by "printerId:gcodeFileName" to avoid duplicate recording.
-    /// </summary>
-    private readonly HashSet<string> _recordedJobs = new();
-
-    public MoonrakerUsagePoller(
-        IServiceScopeFactory scopeFactory,
-        ILogger<MoonrakerUsagePoller> logger,
-        IOptions<MoonrakerPollerOptions> options)
-    {
-        _scopeFactory = scopeFactory;
-        _logger = logger;
-        _options = options.Value;
-    }
-
-    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-    {
-        if (!_options.Enabled)
-        {
-            _logger.LogInformation("Moonraker usage poller is disabled via configuration.");
-            return;
-        }
-
-        _logger.LogInformation(
-            "Moonraker usage poller starting. Poll interval: {Interval}",
-            _options.PollInterval);
-
-        while (!stoppingToken.IsCancellationRequested)
-        {
-            try
-            {
-                await PollAllPrintersAsync(stoppingToken);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex,
-                    "Unexpected error in Moonraker usage poller cycle. Continuing.");
-            }
-
-            await Task.Delay(_options.PollInterval, stoppingToken);
-        }
-
-        _logger.LogInformation("Moonraker usage poller stopping.");
-    }
-
-    private async Task PollAllPrintersAsync(CancellationToken cancellationToken)
-    {
-        using var scope = _scopeFactory.CreateScope();
-        var dbContext = scope.ServiceProvider.GetRequiredService<ExtrudexDbContext>();
-        var moonrakerClient = scope.ServiceProvider.GetRequiredService<IMoonrakerClient>();
-        var usageService = scope.ServiceProvider.GetRequiredService<IFilamentUsageService>();
-
-        var printers = await dbContext.Printers
-            .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
-            .ToListAsync(cancellationToken);
-
-        if (printers.Count == 0)
-        {
-            _logger.LogDebug("No active Moonraker printers found.");
-            return;
-        }
-
-        _logger.LogDebug("Polling {Count} Moonraker printer(s).", printers.Count);
-
-        foreach (var printer in printers)
-        {
-            await PollPrinterAsync(
-                printer, moonrakerClient, usageService, dbContext, cancellationToken);
-        }
-    }
-
-    private async Task PollPrinterAsync(
-        Printer printer,
-        IMoonrakerClient moonrakerClient,
-        IFilamentUsageService usageService,
-        ExtrudexDbContext dbContext,
-        CancellationToken cancellationToken)
-    {
-        _logger.LogDebug(
-            "Polling Moonraker printer {PrinterName} ({Host}:{Port})",
-            printer.Name, printer.HostnameOrIp, printer.Port);
-
-        try
-        {
-            var printStats = await moonrakerClient.GetPrintStatsAsync(
-                printer.HostnameOrIp,
-                printer.Port,
-                printer.ApiKey,
-                cancellationToken);
-
-            if (printStats is null)
-            {
-                _logger.LogDebug(
-                    "No print stats available from printer {PrinterName}.", printer.Name);
-                return;
-            }
-
-            printer.LastSeenAt = DateTime.UtcNow;
-            await dbContext.SaveChangesAsync(cancellationToken);
-
-            _logger.LogDebug(
-                "Printer {PrinterName}: state={State}, filament={Mm}mm, file={File}",
-                printer.Name, printStats.State, printStats.FilamentUsedMm, printStats.Filename);
-
-            decimal mmExtruded = printStats.FilamentUsedMm;
-            if (mmExtruded <= 0)
-            {
-                _logger.LogDebug(
-                    "Printer {PrinterName} has no filament usage to record.", printer.Name);
-                return;
-            }
-
-            if (!IsCompleteState(printStats.State))
-            {
-                _logger.LogDebug(
-                    "Printer {PrinterName} print state '{State}' is not complete; skipping.",
-                    printer.Name, printStats.State);
-                return;
-            }
-
-            string gcodeFileName = printStats.Filename ?? $"unknown-{Guid.NewGuid():N}";
-            var deduplicationKey = $"{printer.Id}:{gcodeFileName}";
-            if (_recordedJobs.Contains(deduplicationKey))
-            {
-                _logger.LogDebug(
-                    "Printer {PrinterName} job '{File}' already recorded; skipping.",
-                    printer.Name, gcodeFileName);
-                return;
-            }
-
-            DateTime? startedAt = null;
-            DateTime? completedAt = null;
-            try
-            {
-                var history = await moonrakerClient.GetPrintHistoryAsync(
-                    printer.HostnameOrIp, printer.Port, printer.ApiKey,
-                    limit: 1, cancellationToken);
-
-                if (history.Items.Count > 0)
-                {
-                    var latestJob = history.Items[0];
-                    startedAt = latestJob.StartTime;
-                    completedAt = latestJob.EndTime;
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogDebug(ex,
-                    "Could not fetch history for printer {PrinterName}; proceeding with stats only.",
-                    printer.Name);
-            }
-
-            var printJob = await FindOrCreatePrintJobAsync(
-                dbContext, printer, mmExtruded, gcodeFileName,
-                startedAt, completedAt, cancellationToken);
-
-            if (printJob is null)
-            {
-                _logger.LogWarning(
-                    "Could not find or create print job for printer {PrinterName}. No active spool found.",
-                    printer.Name);
-                return;
-            }
-
-            var spool = await dbContext.Spools.FindAsync(
-                new object[] { printJob.SpoolId }, cancellationToken);
-
-            var gramsUsed = CalculateGramsUsed(mmExtruded, spool);
-
-            await usageService.RecordUsageAsync(
-                printJobId: printJob.Id,
-                spoolId: printJob.SpoolId,
-                printerId: printer.Id,
-                gramsUsed: gramsUsed,
-                mmExtruded: mmExtruded,
-                notes: $"Moonraker auto-recorded: {gcodeFileName}",
-                cancellationToken: cancellationToken);
-
-            _recordedJobs.Add(deduplicationKey);
-
-            _logger.LogInformation(
-                "Recorded Moonraker usage for printer {PrinterName}: {Mm}mm / {Grams}g, job '{File}'",
-                printer.Name, mmExtruded, gramsUsed, gcodeFileName);
-        }
-        catch (HttpRequestException ex)
-        {
-            _logger.LogWarning(ex,
-                "Moonraker API unreachable for printer {PrinterName} ({Host}:{Port}). Will retry next cycle.",
-                printer.Name, printer.HostnameOrIp, printer.Port);
-        }
-        catch (TaskCanceledException) when (cancellationToken.IsCancellationRequested)
-        {
-            throw;
-        }
-        catch (TaskCanceledException ex)
-        {
-            _logger.LogWarning(ex,
-                "Moonraker request timed out for printer {PrinterName} ({Host}:{Port}).",
-                printer.Name, printer.HostnameOrIp, printer.Port);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex,
-                "Unexpected error polling Moonraker printer {PrinterName}. Continuing to next printer.",
-                printer.Name);
-        }
-    }
-
-    private static bool IsCompleteState(string state) =>
-        state.Equals("complete", StringComparison.OrdinalIgnoreCase) ||
-        state.Equals("completed", StringComparison.OrdinalIgnoreCase);
-
-    private async Task<PrintJob?> FindOrCreatePrintJobAsync(
-        ExtrudexDbContext dbContext,
-        Printer printer,
-        decimal mmExtruded,
-        string gcodeFileName,
-        DateTime? startedAt,
-        DateTime? completedAt,
-        CancellationToken cancellationToken)
-    {
-        if (!string.IsNullOrEmpty(gcodeFileName))
-        {
-            var existingJob = await dbContext.PrintJobs
-                .Where(j => j.PrinterId == printer.Id &&
-                            j.GcodeFilePath == gcodeFileName &&
-                            j.DataSource == DataSource.Moonraker &&
-                            j.Status != JobStatus.Cancelled)
-                .OrderByDescending(j => j.CreatedAt)
-                .FirstOrDefaultAsync(cancellationToken);
-
-            if (existingJob is not null)
-            {
-                existingJob.MmExtruded = mmExtruded;
-                existingJob.GramsDerived = CalculateGramsUsed(
-                    mmExtruded,
-                    await dbContext.Spools.FindAsync(
-                        new object[] { existingJob.SpoolId }, cancellationToken));
-                existingJob.Status = JobStatus.Completed;
-                existingJob.CompletedAt = completedAt ?? DateTime.UtcNow;
-                existingJob.StartedAt ??= startedAt;
-                await dbContext.SaveChangesAsync(cancellationToken);
-                return existingJob;
-            }
-        }
-
-        var spool = await FindActiveSpoolForPrinterAsync(dbContext, printer, cancellationToken);
-        if (spool is null) return null;
-
-        var gramsDerived = CalculateGramsUsed(mmExtruded, spool);
-
-        var newJob = new PrintJob
-        {
-            PrinterId = printer.Id,
-            SpoolId = spool.Id,
-            PrintName = gcodeFileName ?? "Moonraker Print",
-            GcodeFilePath = gcodeFileName,
-            MmExtruded = mmExtruded,
-            GramsDerived = gramsDerived,
-            FilamentDiameterAtPrintMm = spool.FilamentDiameterMm,
-            MaterialDensityAtPrint = GetMaterialDensity(spool),
-            DataSource = DataSource.Moonraker,
-            Status = JobStatus.Completed,
-            StartedAt = startedAt ?? DateTime.UtcNow,
-            CompletedAt = completedAt ?? DateTime.UtcNow,
-            Notes = "Auto-created by Moonraker usage poller"
-        };
-
-        dbContext.PrintJobs.Add(newJob);
-        await dbContext.SaveChangesAsync(cancellationToken);
-
-        return newJob;
-    }
-
-    private static async Task<Spool?> FindActiveSpoolForPrinterAsync(
-        ExtrudexDbContext dbContext,
-        Printer printer,
-        CancellationToken cancellationToken)
-    {
-        var amsSpool = await dbContext.AmsSlots
-            .Include(s => s.Spool)
-            .ThenInclude(s => s!.MaterialBase)
-            .Include(s => s.AmsUnit)
-            .Where(s => s.AmsUnit.PrinterId == printer.Id && s.Spool != null && s.Spool.IsActive)
-            .Select(s => s.Spool)
-            .FirstOrDefaultAsync(cancellationToken);
-
-        if (amsSpool is not null) return amsSpool;
-
-        return await dbContext.Spools
-            .Include(s => s.MaterialBase)
-            .Where(s => s.IsActive)
-            .OrderByDescending(s => s.WeightRemainingGrams)
-            .FirstOrDefaultAsync(cancellationToken);
-    }
-
-    private static decimal CalculateGramsUsed(decimal mmExtruded, Spool? spool)
-    {
-        if (spool is null) return 0m;
-        var diameterMm = spool.FilamentDiameterMm;
-        var densityGcm3 = GetMaterialDensity(spool);
-        var radiusMm = diameterMm / 2m;
-        var crossSectionArea = Math.PI * (double)radiusMm * (double)radiusMm;
-        var volumeMm3 = (double)mmExtruded * crossSectionArea;
-        var volumeCm3 = volumeMm3 / 1000.0;
-        var grams = volumeCm3 * (double)densityGcm3;
-        return Math.Round((decimal)grams, 2);
-    }
-
-    private static decimal GetMaterialDensity(Spool? spool)
-    {
-        return spool?.MaterialBase?.Name?.ToUpperInvariant() switch
-        {
-            "PLA" => 1.24m,
-            "PETG" => 1.27m,
-            "ABS" => 1.04m,
-            "ASA" => 1.07m,
-            "TPU" => 1.21m,
-            "NYLON" or "PA" => 1.13m,
-            "PC" => 1.20m,
-            _ => 1.24m
-        };
-    }
-}

backend/Program.cs

@@ -61,14 +61,6 @@ builder.Services.AddSingleton<ILowStockDetector, LowStockDetector>();
 // ── Usage Logging ───────────────────────────────────────────
 builder.Services.AddScoped<IUsageLogService, UsageLogService>();
 
-// ── Filament Usage Service ──────────────────────────────────
-builder.Services.AddScoped<IFilamentUsageService, FilamentUsageService>();
-
-// ── Moonraker Usage Poller (Background Service) ─────────────
-builder.Services.Configure<MoonrakerPollerOptions>(
-    builder.Configuration.GetSection("MoonrakerPoller"));
-builder.Services.AddHostedService<MoonrakerUsagePoller>();
-
 // ── FluentValidation ──────────────────────────────────────
 // Registers all validators from the API assembly into DI.
 builder.Services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());

backend/appsettings.json

@@ -23,11 +23,5 @@
   },
   "FilamentAlerts": {
     "LowStockThresholdPercent": 20
-  },
-  "MoonrakerPoller": {
-    "Enabled": true,
-    "PollInterval": "00:00:30",
-    "RequestTimeout": "00:00:10"
   }
 }
-}

backend/cmd/server/main.go

@@ -1,80 +0,0 @@
-package main
-
-import (
-	"context"
-	"log/slog"
-	"net/http"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
-
-	"github.com/CubeCraft-Creations/Extrudex/backend/internal/config"
-	"github.com/CubeCraft-Creations/Extrudex/backend/internal/db"
-	"github.com/CubeCraft-Creations/Extrudex/backend/internal/router"
-)
-
-func main() {
-	// Setup structured logging
-	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-		Level: slog.LevelInfo,
-	})))
-
-	// Load configuration
-	cfg, err := config.Load()
-	if err != nil {
-		slog.Error("failed to load config", "error", err)
-		os.Exit(1)
-	}
-
-	slog.Info("config loaded", "port", cfg.Port, "cors_origin", cfg.CorsOrigin)
-
-	// Connect to database
-	dbPool, err := db.NewPool(cfg.DatabaseURL)
-	if err != nil {
-		slog.Error("failed to connect to database", "error", err)
-		os.Exit(1)
-	}
-	defer db.ClosePool(dbPool)
-
-	slog.Info("database connected")
-
-	// Create router
-	r := router.New(cfg, dbPool)
-
-	// Create HTTP server
-	server := &http.Server{
-		Addr:         ":" + cfg.Port,
-		Handler:      r,
-		ReadTimeout:  15 * time.Second,
-		WriteTimeout: 15 * time.Second,
-		IdleTimeout:  60 * time.Second,
-	}
-
-	// Start server in goroutine
-	go func() {
-		slog.Info("server starting", "addr", server.Addr)
-		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			slog.Error("server error", "error", err)
-			os.Exit(1)
-		}
-	}()
-
-	// Wait for shutdown signal
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-	<-quit
-
-	slog.Info("server shutting down")
-
-	// Graceful shutdown
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	if err := server.Shutdown(ctx); err != nil {
-		slog.Error("server shutdown error", "error", err)
-	}
-
-	db.ClosePool(dbPool)
-	slog.Info("server stopped")
-}

backend/go.mod

@@ -1,9 +0,0 @@
-module github.com/CubeCraft-Creations/Extrudex/backend
-
-go 1.24
-
-require (
-	github.com/go-chi/chi/v5 v5.2.0
-	github.com/jackc/pgx/v5 v5.7.4
-	github.com/kelseyhightower/envconfig v1.4.0
-)

backend/internal/config/config.go

@@ -1,24 +0,0 @@
-package config
-
-import (
-	"fmt"
-
-	"github.com/kelseyhightower/envconfig"
-)
-
-// Config holds all application configuration loaded from environment variables.
-type Config struct {
-	DatabaseURL string `envconfig:"database_url" required:"true"`
-	Port        string `envconfig:"port" default:"8080"`
-	CorsOrigin  string `envconfig:"cors_origin" default:"*"`
-	LogLevel    string `envconfig:"log_level" default:"info"`
-}
-
-// Load reads configuration from environment variables and returns a populated Config.
-func Load() (*Config, error) {
-	var cfg Config
-	if err := envconfig.Process("", &cfg); err != nil {
-		return nil, fmt.Errorf("failed to load config: %w", err)
-	}
-	return &cfg, nil
-}

backend/internal/db/db.go

@@ -1,34 +0,0 @@
-package db
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// NewPool creates a new pgx connection pool and verifies connectivity with a ping.
-func NewPool(databaseURL string) (*pgxpool.Pool, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
-	pool, err := pgxpool.New(ctx, databaseURL)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create db pool: %w", err)
-	}
-
-	if err := pool.Ping(ctx); err != nil {
-		pool.Close()
-		return nil, fmt.Errorf("failed to ping db: %w", err)
-	}
-
-	return pool, nil
-}
-
-// ClosePool gracefully closes the connection pool.
-func ClosePool(pool *pgxpool.Pool) {
-	if pool != nil {
-		pool.Close()
-	}
-}

backend/internal/handlers/health.go

@@ -1,50 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"encoding/json"
-	"log/slog"
-	"net/http"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// HealthHandler provides a health check endpoint that verifies database connectivity.
-type HealthHandler struct {
-	dbPool *pgxpool.Pool
-}
-
-// NewHealthHandler creates a new HealthHandler with the given database pool.
-func NewHealthHandler(dbPool *pgxpool.Pool) *HealthHandler {
-	return &HealthHandler{dbPool: dbPool}
-}
-
-// ServeHTTP handles GET /health requests.
-func (h *HealthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
-	defer cancel()
-
-	dbConnected := false
-	if h.dbPool != nil {
-		if err := h.dbPool.Ping(ctx); err == nil {
-			dbConnected = true
-		} else {
-			slog.Warn("health check db ping failed", "error", err)
-		}
-	}
-
-	resp := map[string]any{
-		"status":       "ok",
-		"timestamp":    time.Now().UTC().Format(time.RFC3339),
-		"db_connected": dbConnected,
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	if !dbConnected {
-		w.WriteHeader(http.StatusServiceUnavailable)
-	}
-	if err := json.NewEncoder(w).Encode(resp); err != nil {
-		slog.Error("failed to encode health response", "error", err)
-	}
-}

backend/internal/repositories/.gitkeep

@@ -1 +0,0 @@
-# Repositories

backend/internal/router/router.go

@@ -1,45 +0,0 @@
-package router
-
-import (
-	"log/slog"
-	"net/http"
-	"time"
-
-	"github.com/CubeCraft-Creations/Extrudex/backend/internal/config"
-	"github.com/CubeCraft-Creations/Extrudex/backend/internal/handlers"
-	"github.com/go-chi/chi/v5"
-	"github.com/go-chi/chi/v5/middleware"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// New creates and configures a Chi router with all middleware and handlers mounted.
-func New(cfg *config.Config, dbPool *pgxpool.Pool) chi.Router {
-	r := chi.NewRouter()
-
-	// Middleware
-	r.Use(middleware.RequestID)
-	r.Use(middleware.RealIP)
-	r.Use(middleware.Logger)
-	r.Use(middleware.Recoverer)
-	r.Use(middleware.Timeout(60 * time.Second))
-
-	// CORS
-	r.Use(func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Access-Control-Allow-Origin", cfg.CorsOrigin)
-			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-			w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
-			if r.Method == http.MethodOptions {
-				w.WriteHeader(http.StatusNoContent)
-				return
-			}
-			next.ServeHTTP(w, r)
-		})
-	})
-
-	// Health check
-	healthHandler := handlers.NewHealthHandler(dbPool)
-	r.Get("/health", healthHandler.ServeHTTP)
-
-	return r
-}

backend/internal/services/.gitkeep

@@ -1 +0,0 @@
-# Services