merge(dev): Re-apply changes after conflict resolution

Merge remote-tracking branch 'origin/dev' into fix-pr-11
# Conflicts: # backend/Program.cs
2026-04-27 18:16:43 -04:00 · 2026-04-27 18:16:43 -04:00 · 2026-04-27 14:29:13 -04:00 · 2026-04-26 18:44:02 +00:00
30 changed files with 2140 additions and 1468 deletions
--- a/backend/API/Controllers/CostAnalysisController.cs
+++ b/backend/API/Controllers/CostAnalysisController.cs
@@ -1,108 +0,0 @@
 using Extrudex.API.DTOs.PrintJobs;
 using Extrudex.Domain.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace Extrudex.API.Controllers;
 /// <summary>
 /// Controller for cost analysis endpoints. Provides spool-level
 /// cost breakdowns and aggregated COGS reporting.
 /// </summary>
 [ApiController]
 [Route("api/cost-analysis")]
 public class CostAnalysisController : ControllerBase
 {
    private readonly ICostPerPrintService _costService;
    private readonly ILogger<CostAnalysisController> _logger;
    /// <summary>
    /// Initializes a new instance of the <see cref="CostAnalysisController"/> class.
    /// </summary>
    /// <param name="costService">The cost-per-print calculation service.</param>
    /// <param name="logger">The logger for diagnostic output.</param>
    public CostAnalysisController(
        ICostPerPrintService costService,
        ILogger<CostAnalysisController> logger)
    {
        _costService = costService;
        _logger = logger;
    }
    // ── POST /api/cost-analysis/spool ────────────────────────────
    /// <summary>
    /// Calculates cost breakdowns for all print jobs associated with a specific spool.
    /// Returns per-job costs plus an aggregated total. Jobs with missing cost data
    /// include warnings and null cost fields — the endpoint never throws for missing data.
    /// </summary>
    /// <param name="request">The request containing the spool identifier.</param>
    /// <returns>A spool-level cost summary with per-job breakdowns.</returns>
    /// <response code="200">Returns the spool cost breakdown with per-job details.</response>
    /// <response code="404">If the spool has no print jobs.</response>
    [HttpPost("spool")]
    [ProducesResponseType(typeof(SpoolCostResponse), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<SpoolCostResponse>> CalculateSpoolCost([FromBody] SpoolCostRequest request)
    {
        _logger.LogDebug("Calculating cost breakdown for spool {SpoolId}", request.SpoolId);
        var results = await _costService.CalculateBySpoolAsync(request.SpoolId);
        if (results.Count == 0)
        {
            return NotFound(new { error = $"No print jobs found for spool with ID '{request.SpoolId}'." });
        }
        // Build the spool-level summary
        var firstResult = results[0];
        var jobResponses = results.Select(MapCostToResponse).ToList();
        // Aggregate total cost and grams — only include jobs that have a valid cost
        var calculableJobs = results.Where(r => r.CostPerPrint.HasValue).ToList();
        var totalCost = calculableJobs.Count == results.Count
            ? Math.Round(calculableJobs.Sum(r => r.CostPerPrint!.Value), 4)
            : (decimal?)null;
        var aggregateWarnings = new List<string>();
        if (calculableJobs.Count < results.Count)
        {
            aggregateWarnings.Add(
                $"{results.Count - calculableJobs.Count} of {results.Count} print jobs have missing cost data. " +
                "Total cost reflects only jobs with complete data.");
        }
        var response = new SpoolCostResponse
        {
            SpoolId = request.SpoolId,
            SpoolSerial = firstResult.SpoolSerial,
            PurchasePrice = firstResult.PurchasePrice,
            WeightTotalGrams = firstResult.WeightTotalGrams,
            CostPerGram = firstResult.CostPerGram,
            TotalGramsConsumed = results.Sum(r => r.GramsDerived),
            TotalCost = totalCost,
            JobCount = results.Count,
            Jobs = jobResponses,
            Warnings = aggregateWarnings
        };
        return Ok(response);
    }
    /// <summary>
    /// Maps a domain CostPerPrintResult to an API CostPerPrintResponse DTO.
    /// </summary>
    private static CostPerPrintResponse MapCostToResponse(CostPerPrintResult r) => new()
    {
        PrintJobId = r.PrintJobId,
        PrintName = r.PrintName,
        SpoolId = r.SpoolId,
        SpoolSerial = r.SpoolSerial,
        MmExtruded = r.MmExtruded,
        GramsDerived = r.GramsDerived,
        PurchasePrice = r.PurchasePrice,
        WeightTotalGrams = r.WeightTotalGrams,
        CostPerGram = r.CostPerGram,
        CostPerPrint = r.CostPerPrint,
        Warnings = r.Warnings
    };
 }
--- a/backend/API/Controllers/UsageLogsController.cs
+++ b/backend/API/Controllers/UsageLogsController.cs
@@ -0,0 +1,117 @@
 using Extrudex.API.DTOs.UsageLogs;
 using Extrudex.Domain.Enums;
 using Extrudex.Domain.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 namespace Extrudex.API.Controllers;
 /// <summary>
 /// API controller for recording and querying filament usage logs.
 /// Usage logs provide a fine-grained audit trail of filament consumption
 /// from printer integrations or manual input.
 /// </summary>
 [ApiController]
 [Route("api/[controller]")]
 [Produces("application/json")]
 public class UsageLogsController : ControllerBase
 {
    private readonly IUsageLogService _usageLogService;
    /// <summary>
    /// Initializes a new instance of the <see cref="UsageLogsController"/> class.
    /// </summary>
    /// <param name="usageLogService">The usage log service for recording and querying usage.</param>
    public UsageLogsController(IUsageLogService usageLogService)
    {
        _usageLogService = usageLogService;
    }
    /// <summary>
    /// Records a new filament usage entry.
    /// </summary>
    /// <param name="request">The usage entry details.</param>
    /// <returns>The created usage log entry.</returns>
    [HttpPost]
    [ProducesResponseType(typeof(UsageLogResponse), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<UsageLogResponse>> Create([FromBody] CreateUsageLogRequest request)
    {
        if (!Enum.TryParse<DataSource>(request.DataSource, ignoreCase: true, out var dataSource))
        {
            return BadRequest($"Invalid data source: '{request.DataSource}'. Valid values: Mqtt, Moonraker, Manual.");
        }
        var entry = await _usageLogService.RecordUsageAsync(
            spoolId: request.SpoolId,
            gramsUsed: request.GramsUsed,
            dataSource: dataSource,
            printerId: request.PrinterId,
            printJobId: request.PrintJobId,
            mmExtruded: request.MmExtruded,
            usageTimestamp: request.UsageTimestamp,
            notes: request.Notes
        );
        return CreatedAtAction(
            nameof(GetBySpool),
            new { spoolId = entry.SpoolId },
            MapToResponse(entry));
    }
    /// <summary>
    /// Gets usage logs for a specific spool, ordered by most recent first.
    /// </summary>
    /// <param name="spoolId">The spool ID to filter by.</param>
    /// <returns>A collection of usage log entries for the spool.</returns>
    [HttpGet("spool/{spoolId:guid}")]
    [ProducesResponseType(typeof(IEnumerable<UsageLogResponse>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IEnumerable<UsageLogResponse>>> GetBySpool(Guid spoolId)
    {
        var logs = await _usageLogService.GetBySpoolAsync(spoolId);
        return Ok(logs.Select(MapToResponse));
    }
    /// <summary>
    /// Gets usage logs for a specific printer, ordered by most recent first.
    /// </summary>
    /// <param name="printerId">The printer ID to filter by.</param>
    /// <returns>A collection of usage log entries for the printer.</returns>
    [HttpGet("printer/{printerId:guid}")]
    [ProducesResponseType(typeof(IEnumerable<UsageLogResponse>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IEnumerable<UsageLogResponse>>> GetByPrinter(Guid printerId)
    {
        var logs = await _usageLogService.GetByPrinterAsync(printerId);
        return Ok(logs.Select(MapToResponse));
    }
    /// <summary>
    /// Gets usage logs for a specific print job, ordered by most recent first.
    /// </summary>
    /// <param name="printJobId">The print job ID to filter by.</param>
    /// <returns>A collection of usage log entries for the print job.</returns>
    [HttpGet("print-job/{printJobId:guid}")]
    [ProducesResponseType(typeof(IEnumerable<UsageLogResponse>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IEnumerable<UsageLogResponse>>> GetByPrintJob(Guid printJobId)
    {
        var logs = await _usageLogService.GetByPrintJobAsync(printJobId);
        return Ok(logs.Select(MapToResponse));
    }
    /// <summary>
    /// Maps a UsageLog domain entity to a UsageLogResponse DTO.
    /// </summary>
    private static UsageLogResponse MapToResponse(Domain.Entities.UsageLog log) => new()
    {
        Id = log.Id,
        SpoolId = log.SpoolId,
        PrinterId = log.PrinterId,
        PrintJobId = log.PrintJobId,
        GramsUsed = log.GramsUsed,
        MmExtruded = log.MmExtruded,
        UsageTimestamp = log.UsageTimestamp,
        DataSource = log.DataSource.ToString(),
        Notes = log.Notes,
        CreatedAt = log.CreatedAt,
        UpdatedAt = log.UpdatedAt
    };
 }
--- a/backend/API/DTOs/PrintJobs/CostPerPrintDtos.cs
+++ b/backend/API/DTOs/PrintJobs/CostPerPrintDtos.cs
@@ -1,99 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 namespace Extrudex.API.DTOs.PrintJobs;
 /// <summary>
 /// Response DTO for cost-per-print calculation. Contains the full cost
 /// breakdown and any warnings about missing or incomplete data.
 /// </summary>
 public class CostPerPrintResponse
 {
    /// <summary>The print job identifier this result belongs to.</summary>
    public Guid PrintJobId { get; set; }
    /// <summary>Human-readable name of the print job.</summary>
    public string PrintName { get; set; } = string.Empty;
    /// <summary>The spool identifier that provided filament.</summary>
    public Guid SpoolId { get; set; }
    /// <summary>Serial number of the spool.</summary>
    public string SpoolSerial { get; set; } = string.Empty;
    /// <summary>Total millimeters of filament extruded.</summary>
    public decimal MmExtruded { get; set; }
    /// <summary>Derived grams consumed for this print.</summary>
    public decimal GramsDerived { get; set; }
    /// <summary>The spool's purchase price. Null if not recorded.</summary>
    public decimal? PurchasePrice { get; set; }
    /// <summary>The spool's total weight in grams when full.</summary>
    public decimal? WeightTotalGrams { get; set; }
    /// <summary>Cost per gram of filament. Null if purchase price or total weight is missing.</summary>
    public decimal? CostPerGram { get; set; }
    /// <summary>Calculated cost of this print job. Null if cost data is incomplete.</summary>
    public decimal? CostPerPrint { get; set; }
    /// <summary>
    /// Warnings about missing or incomplete data. Empty when all data is available
    /// and the calculation succeeded.
    /// </summary>
    public List<string> Warnings { get; set; } = new();
 }
 /// <summary>
 /// Request DTO for batch cost calculation by spool. Returns cost breakdowns
 /// for all print jobs associated with the specified spool.
 /// </summary>
 public class SpoolCostRequest
 {
    /// <summary>The unique identifier of the spool to calculate costs for.</summary>
    [Required(ErrorMessage = "SpoolId is required.")]
    public Guid SpoolId { get; set; }
 }
 /// <summary>
 /// Response DTO for spool-level cost calculation. Contains cost breakdowns
 /// for all print jobs on the spool, plus a total cost summary.
 /// </summary>
 public class SpoolCostResponse
 {
    /// <summary>The spool identifier.</summary>
    public Guid SpoolId { get; set; }
    /// <summary>Serial number of the spool.</summary>
    public string SpoolSerial { get; set; } = string.Empty;
    /// <summary>The spool's purchase price. Null if not recorded.</summary>
    public decimal? PurchasePrice { get; set; }
    /// <summary>The spool's total weight in grams when full.</summary>
    public decimal? WeightTotalGrams { get; set; }
    /// <summary>Cost per gram of filament. Null if cost data is incomplete.</summary>
    public decimal? CostPerGram { get; set; }
    /// <summary>Total grams consumed across all print jobs on this spool.</summary>
    public decimal TotalGramsConsumed { get; set; }
    /// <summary>Total calculated cost across all print jobs. Null if any job has missing data.</summary>
    public decimal? TotalCost { get; set; }
    /// <summary>Number of print jobs included in this calculation.</summary>
    public int JobCount { get; set; }
    /// <summary>
    /// Individual cost breakdowns per print job. Jobs with missing data
    /// will have null cost fields and populated warnings.
    /// </summary>
    public List<CostPerPrintResponse> Jobs { get; set; } = new();
    /// <summary>
    /// Aggregate warnings about missing data across all jobs.
    /// </summary>
    public List<string> Warnings { get; set; } = new();
 }
--- a/backend/API/DTOs/UsageLogs/UsageLogDtos.cs
+++ b/backend/API/DTOs/UsageLogs/UsageLogDtos.cs
@@ -0,0 +1,115 @@
 using System.ComponentModel.DataAnnotations;
 namespace Extrudex.API.DTOs.UsageLogs;
 /// <summary>
 /// Request DTO for recording a filament usage entry.
 /// </summary>
 public class CreateUsageLogRequest
 {
    /// <summary>
    /// The ID of the spool that provided the filament.
    /// </summary>
    [Required]
    public Guid SpoolId { get; set; }
    /// <summary>
    /// The number of grams of filament consumed.
    /// </summary>
    [Required]
    [Range(0.01, double.MaxValue, ErrorMessage = "GramsUsed must be a positive value.")]
    public decimal GramsUsed { get; set; }
    /// <summary>
    /// The source of the usage data (Mqtt, Moonraker, Manual).
    /// </summary>
    [Required]
    public string DataSource { get; set; } = string.Empty;
    /// <summary>
    /// The ID of the printer that consumed the filament. Optional.
    /// </summary>
    public Guid? PrinterId { get; set; }
    /// <summary>
    /// The ID of the print job associated with this usage. Optional.
    /// </summary>
    public Guid? PrintJobId { get; set; }
    /// <summary>
    /// The number of millimeters of filament extruded. Optional.
    /// </summary>
    public decimal? MmExtruded { get; set; }
    /// <summary>
    /// When the usage occurred (UTC). Defaults to now if not specified.
    /// </summary>
    public DateTime? UsageTimestamp { get; set; }
    /// <summary>
    /// Optional notes about this usage entry.
    /// </summary>
    [MaxLength(2000)]
    public string? Notes { get; set; }
 }
 /// <summary>
 /// Response DTO for a usage log entry.
 /// </summary>
 public class UsageLogResponse
 {
    /// <summary>
    /// Unique identifier for the usage log entry.
    /// </summary>
    public Guid Id { get; set; }
    /// <summary>
    /// The spool that provided the filament.
    /// </summary>
    public Guid SpoolId { get; set; }
    /// <summary>
    /// The printer that consumed the filament, if applicable.
    /// </summary>
    public Guid? PrinterId { get; set; }
    /// <summary>
    /// The print job associated with this usage, if applicable.
    /// </summary>
    public Guid? PrintJobId { get; set; }
    /// <summary>
    /// Grams of filament consumed.
    /// </summary>
    public decimal GramsUsed { get; set; }
    /// <summary>
    /// Millimeters of filament extruded, if available.
    /// </summary>
    public decimal? MmExtruded { get; set; }
    /// <summary>
    /// When the usage occurred (UTC).
    /// </summary>
    public DateTime UsageTimestamp { get; set; }
    /// <summary>
    /// Source of the usage data (Mqtt, Moonraker, Manual).
    /// </summary>
    public string DataSource { get; set; } = string.Empty;
    /// <summary>
    /// Optional notes about this usage entry.
    /// </summary>
    public string? Notes { get; set; }
    /// <summary>
    /// When the record was created (UTC).
    /// </summary>
    public DateTime CreatedAt { get; set; }
    /// <summary>
    /// When the record was last updated (UTC).
    /// </summary>
    public DateTime UpdatedAt { get; set; }
 }
--- a/backend/API/Jobs/FilamentUsageSyncJob.cs
+++ b/backend/API/Jobs/FilamentUsageSyncJob.cs
@@ -1,79 +0,0 @@
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Configuration;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 namespace Extrudex.API.Jobs;
 /// <summary>
 /// Background job that periodically syncs filament usage data from
 /// Moonraker printers. Runs as a hosted service and polls all active
 /// Moonraker printers on a configurable interval to persist usage
 /// data to the Extrudex database.
 /// 
 /// Configuration is bound from the "FilamentUsageSync" section in
 /// appsettings.json. Set Enabled=false to disable without removing
 /// the service registration.
 /// </summary>
 public class FilamentUsageSyncJob : BackgroundService
 {
    private readonly IFilamentUsageSyncService _syncService;
    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="options">Configuration options for polling interval and timeouts.</param>
    /// <param name="logger">Logger for diagnostic output.</param>
    public FilamentUsageSyncJob(
        IFilamentUsageSyncService syncService,
        IOptions<FilamentUsageSyncOptions> options,
        ILogger<FilamentUsageSyncJob> logger)
    {
        _syncService = syncService;
        _options = options.Value;
        _logger = logger;
    }
    /// <inheritdoc />
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        if (!_options.Enabled)
        {
            _logger.LogInformation("Filament usage sync job is disabled via configuration — exiting");
            return;
        }
        _logger.LogInformation(
            "Filament usage sync job starting — polling every {Interval}",
            _options.PollingInterval);
        // Delay briefly on startup to allow the web host to fully initialize
        await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                var syncedCount = await _syncService.SyncAllAsync(stoppingToken);
                _logger.LogInformation(
                    "Filament usage sync completed — {SyncedCount} printer(s) synced. Next sync in {Interval}",
                    syncedCount, _options.PollingInterval);
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                _logger.LogError(ex,
                    "Error during filament usage sync cycle — will retry in {Interval}",
                    _options.PollingInterval);
            }
            await Task.Delay(_options.PollingInterval, stoppingToken);
        }
        _logger.LogInformation("Filament usage sync job shutting down");
    }
 }
--- a/backend/Dockerfile
+++ b/backend/Dockerfile
@@ -17,9 +17,6 @@ RUN dotnet publish Extrudex.csproj \
 FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS runtime
 WORKDIR /app
 # 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/*
 # Non-root user for security
 RUN adduser --disabled-password --gecos "" appuser
 USER appuser
--- a/backend/Domain/Entities/UsageLog.cs
+++ b/backend/Domain/Entities/UsageLog.cs
@@ -0,0 +1,72 @@
 using Extrudex.Domain.Base;
 using Extrudex.Domain.Enums;
 namespace Extrudex.Domain.Entities;
 /// <summary>
 /// Represents a single filament usage log entry. Records how much filament
 /// was consumed, by which printer, at what time, and optionally linked to
 /// a print job. This provides a fine-grained audit trail of filament consumption
 /// independent of print job lifecycle.
 /// </summary>
 public class UsageLog : AuditableEntity
 {
    /// <summary>
    /// Foreign key to the spool that provided the filament.
    /// </summary>
    public Guid SpoolId { get; set; }
    /// <summary>
    /// Navigation to the spool that provided the filament.
    /// </summary>
    public Spool Spool { get; set; } = null!;
    /// <summary>
    /// Foreign key to the printer that consumed the filament.
    /// Nullable to support manual entries without a specific printer.
    /// </summary>
    public Guid? PrinterId { get; set; }
    /// <summary>
    /// Navigation to the printer that consumed the filament.
    /// </summary>
    public Printer? Printer { get; set; }
    /// <summary>
    /// Foreign key to the print job associated with this usage entry.
    /// Nullable because usage can be logged before or without a print job.
    /// </summary>
    public Guid? PrintJobId { get; set; }
    /// <summary>
    /// Navigation to the print job associated with this usage entry.
    /// </summary>
    public PrintJob? PrintJob { get; set; }
    /// <summary>
    /// The number of grams of filament consumed in this usage event.
    /// </summary>
    public decimal GramsUsed { get; set; }
    /// <summary>
    /// The number of millimeters of filament extruded in this usage event.
    /// Optional — may not be available for all data sources.
    /// </summary>
    public decimal? MmExtruded { get; set; }
    /// <summary>
    /// Timestamp when the usage occurred (UTC). This is the actual time of
    /// consumption, which may differ from CreatedAt if the entry was recorded later.
    /// </summary>
    public DateTime UsageTimestamp { get; set; } = DateTime.UtcNow;
    /// <summary>
    /// The source of the usage data (which integration path provided it).
    /// </summary>
    public DataSource DataSource { get; set; } = DataSource.Manual;
    /// <summary>
    /// Optional notes about this usage entry.
    /// </summary>
    public string? Notes { get; set; }
 }
--- a/backend/Domain/Interfaces/ICostPerPrintService.cs
+++ b/backend/Domain/Interfaces/ICostPerPrintService.cs
@@ -1,76 +0,0 @@
 namespace Extrudex.Domain.Interfaces;
 /// <summary>
 /// Service interface for calculating the cost of goods sold (COGS) per print job.
 /// Uses the spool's purchase price and the print job's derived grams consumed
 /// to produce a cost breakdown. Handles missing cost data gracefully by returning
 /// warnings rather than throwing exceptions.
 /// </summary>
 public interface ICostPerPrintService
 {
    /// <summary>
    /// Calculates the cost per print for a specific print job.
    /// </summary>
    /// <param name="printJobId">The unique identifier of the print job.</param>
    /// <param name="cancellationToken">Optional cancellation token.</param>
    /// <returns>
    /// A <see cref="CostPerPrintResult"/> containing the cost breakdown,
    /// or warnings if cost data is missing or incomplete.
    /// </returns>
    Task<CostPerPrintResult> CalculateAsync(Guid printJobId, CancellationToken cancellationToken = default);
    /// <summary>
    /// Calculates cost breakdowns for all print jobs associated with a specific spool.
    /// Useful for spool-level COGS reporting.
    /// </summary>
    /// <param name="spoolId">The unique identifier of the spool.</param>
    /// <param name="cancellationToken">Optional cancellation token.</param>
    /// <returns>
    /// A list of <see cref="CostPerPrintResult"/> for each print job on the spool.
    /// Jobs with missing cost data will include warnings.
    /// </returns>
    Task<IReadOnlyList<CostPerPrintResult>> CalculateBySpoolAsync(Guid spoolId, CancellationToken cancellationToken = default);
 }
 /// <summary>
 /// Result of a cost-per-print calculation. Contains the cost breakdown
 /// and any warnings about missing or incomplete cost data.
 /// </summary>
 public class CostPerPrintResult
 {
    /// <summary>The print job identifier this result belongs to.</summary>
    public Guid PrintJobId { get; set; }
    /// <summary>Human-readable name of the print job.</summary>
    public string PrintName { get; set; } = string.Empty;
    /// <summary>The spool identifier that provided filament.</summary>
    public Guid SpoolId { get; set; }
    /// <summary>Serial number of the spool.</summary>
    public string SpoolSerial { get; set; } = string.Empty;
    /// <summary>Total millimeters of filament extruded.</summary>
    public decimal MmExtruded { get; set; }
    /// <summary>Derived grams consumed for this print.</summary>
    public decimal GramsDerived { get; set; }
    /// <summary>The spool's purchase price. Null if not recorded.</summary>
    public decimal? PurchasePrice { get; set; }
    /// <summary>The spool's total weight in grams when full.</summary>
    public decimal? WeightTotalGrams { get; set; }
    /// <summary>Cost per gram of filament. Null if purchase price or total weight is missing.</summary>
    public decimal? CostPerGram { get; set; }
    /// <summary>Calculated cost of this print job. Null if cost data is incomplete.</summary>
    public decimal? CostPerPrint { get; set; }
    /// <summary>
    /// Warnings about missing or incomplete data that prevented a full calculation.
    /// Empty when all data is available and the calculation succeeded.
    /// </summary>
    public List<string> Warnings { get; set; } = new();
 }
--- a/backend/Domain/Interfaces/IFilamentUsageSyncService.cs
+++ b/backend/Domain/Interfaces/IFilamentUsageSyncService.cs
@@ -1,19 +0,0 @@
 namespace Extrudex.Domain.Interfaces;
 /// <summary>
 /// Service interface for syncing filament usage data from printers
 /// into the Extrudex database. Handles querying Moonraker printers,
 /// computing derived usage metrics, and persisting updates to spools
 /// and print job records.
 /// </summary>
 public interface IFilamentUsageSyncService
 {
    /// <summary>
    /// Performs a single sync cycle: queries all active Moonraker printers,
    /// fetches their current filament usage data, and persists updates to
    /// the database.
    /// </summary>
    /// <param name="cancellationToken">Cancellation token for graceful shutdown.</param>
    /// <returns>The number of printers successfully synced.</returns>
    Task<int> SyncAllAsync(CancellationToken cancellationToken = default);
 }
--- a/backend/Domain/Interfaces/IMoonrakerClient.cs
+++ b/backend/Domain/Interfaces/IMoonrakerClient.cs
@@ -1,39 +0,0 @@
 namespace Extrudex.Domain.Interfaces;
 /// <summary>
 /// Client interface for communicating with Moonraker REST API endpoints
 /// on Klipper-based printers (e.g., Elegoo Centauri Carbon).
 /// Used to retrieve filament usage data, print job status, and
 /// remaining spool weight from the printer.
 /// </summary>
 public interface IMoonrakerClient
 {
    /// <summary>
    /// Fetches the current filament usage data from the Moonraker server.
    /// Returns a dictionary of usage metrics reported by the printer.
    /// </summary>
    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
    /// <param name="port">The Moonraker API port (default: 7125).</param>
    /// <param name="apiKey">Optional API key for authentication.</param>
    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
    /// <returns>A dictionary of usage metric names to their decimal values.</returns>
    Task<Dictionary<string, decimal>> GetFilamentUsageAsync(
        string hostnameOrIp,
        int port,
        string? apiKey,
        CancellationToken cancellationToken = default);
    /// <summary>
    /// Checks whether the Moonraker server is reachable and responding.
    /// </summary>
    /// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
    /// <param name="port">The Moonraker API port (default: 7125).</param>
    /// <param name="apiKey">Optional API key for authentication.</param>
    /// <param name="cancellationToken">Cancellation token for the HTTP request.</param>
    /// <returns><c>true</c> if the server responded successfully; otherwise <c>false</c>.</returns>
    Task<bool> IsReachableAsync(
        string hostnameOrIp,
        int port,
        string? apiKey,
        CancellationToken cancellationToken = default);
 }
--- a/backend/Domain/Interfaces/IUsageLogService.cs
+++ b/backend/Domain/Interfaces/IUsageLogService.cs
@@ -0,0 +1,57 @@
 using Extrudex.Domain.Entities;
 using Extrudex.Domain.Enums;
 namespace Extrudex.Domain.Interfaces;
 /// <summary>
 /// Service for recording filament usage entries. Writes to the usage_logs table
 /// and provides query capabilities for usage history.
 /// </summary>
 public interface IUsageLogService
 {
    /// <summary>
    /// Records a filament usage entry.
    /// </summary>
    /// <param name="spoolId">The spool that provided the filament.</param>
    /// <param name="gramsUsed">Grams of filament consumed.</param>
    /// <param name="dataSource">Where the data came from.</param>
    /// <param name="printerId">Optional printer ID.</param>
    /// <param name="printJobId">Optional print job ID.</param>
    /// <param name="mmExtruded">Optional mm extruded.</param>
    /// <param name="usageTimestamp">When the usage occurred (defaults to UTC now).</param>
    /// <param name="notes">Optional notes.</param>
    /// <returns>The created UsageLog entity.</returns>
    Task<UsageLog> RecordUsageAsync(
        Guid spoolId,
        decimal gramsUsed,
        DataSource dataSource,
        Guid? printerId = null,
        Guid? printJobId = null,
        decimal? mmExtruded = null,
        DateTime? usageTimestamp = null,
        string? notes = null);
    /// <summary>
    /// Retrieves usage logs for a specific spool, ordered by usage timestamp descending.
    /// </summary>
    /// <param name="spoolId">The spool ID to filter by.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>A collection of usage logs for the spool.</returns>
    Task<IEnumerable<UsageLog>> GetBySpoolAsync(Guid spoolId, CancellationToken cancellationToken = default);
    /// <summary>
    /// Retrieves usage logs for a specific printer, ordered by usage timestamp descending.
    /// </summary>
    /// <param name="printerId">The printer ID to filter by.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>A collection of usage logs for the printer.</returns>
    Task<IEnumerable<UsageLog>> GetByPrinterAsync(Guid printerId, CancellationToken cancellationToken = default);
    /// <summary>
    /// Retrieves usage logs for a specific print job, ordered by usage timestamp descending.
    /// </summary>
    /// <param name="printJobId">The print job ID to filter by.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>A collection of usage logs for the print job.</returns>
    Task<IEnumerable<UsageLog>> GetByPrintJobAsync(Guid printJobId, CancellationToken cancellationToken = default);
 }
--- a/backend/Infrastructure/Configuration/FilamentUsageSyncOptions.cs
+++ b/backend/Infrastructure/Configuration/FilamentUsageSyncOptions.cs
@@ -1,33 +0,0 @@
 namespace Extrudex.Infrastructure.Configuration;
 /// <summary>
 /// Configuration options for the FilamentUsageSync background job.
 /// Bound from appsettings.json under the "FilamentUsageSync" section.
 /// Controls polling interval and per-printer timeout settings.
 /// </summary>
 public class FilamentUsageSyncOptions
 {
    /// <summary>
    /// The section name in appsettings.json where these options are bound.
    /// </summary>
    public const string SectionName = "FilamentUsageSync";
    /// <summary>
    /// How often the background job polls printers for usage data.
    /// Default: 5 minutes. Minimum recommended: 1 minute.
    /// </summary>
    public TimeSpan PollingInterval { get; set; } = TimeSpan.FromMinutes(5);
    /// <summary>
    /// Timeout for individual HTTP requests to a Moonraker printer.
    /// Default: 30 seconds.
    /// </summary>
    public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(30);
    /// <summary>
    /// Whether the sync job is enabled. Set to false to disable
    /// the background job without removing its registration.
    /// Default: true.
    /// </summary>
    public bool Enabled { get; set; } = true;
 }
--- a/backend/Infrastructure/Data/Configurations/UsageLogConfiguration.cs
+++ b/backend/Infrastructure/Data/Configurations/UsageLogConfiguration.cs
@@ -0,0 +1,91 @@
 using Extrudex.Domain.Entities;
 using Extrudex.Domain.Enums;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 namespace Extrudex.Infrastructure.Data.Configurations;
 /// <summary>
 /// EF Core configuration for the UsageLog entity.
 /// Maps to the usage_logs table with snake_case columns and appropriate indexes.
 /// </summary>
 public class UsageLogConfiguration : BaseEntityConfiguration<UsageLog>
 {
    /// <inheritdoc/>
    public override void Configure(EntityTypeBuilder<UsageLog> builder)
    {
        base.Configure(builder);
        builder.Property(e => e.SpoolId)
            .HasColumnName("spool_id")
            .IsRequired();
        builder.Property(e => e.PrinterId)
            .HasColumnName("printer_id");
        builder.Property(e => e.PrintJobId)
            .HasColumnName("print_job_id");
        builder.Property(e => e.GramsUsed)
            .HasColumnName("grams_used")
            .HasPrecision(10, 2)
            .IsRequired();
        builder.Property(e => e.MmExtruded)
            .HasColumnName("mm_extruded")
            .HasPrecision(12, 2);
        builder.Property(e => e.UsageTimestamp)
            .HasColumnName("usage_timestamp")
            .IsRequired();
        builder.Property(e => e.DataSource)
            .HasColumnName("data_source")
            .HasConversion<string>()
            .HasMaxLength(50)
            .IsRequired();
        builder.Property(e => e.Notes)
            .HasColumnName("notes")
            .HasMaxLength(2000);
        // Index on spool_id for querying usage by spool
        builder.HasIndex(e => e.SpoolId)
            .HasDatabaseName("ix_usage_logs_spool_id");
        // Index on printer_id for querying usage by printer
        builder.HasIndex(e => e.PrinterId)
            .HasDatabaseName("ix_usage_logs_printer_id");
        // Index on print_job_id for querying usage by print job
        builder.HasIndex(e => e.PrintJobId)
            .HasDatabaseName("ix_usage_logs_print_job_id");
        // Index on usage_timestamp for chronological queries
        builder.HasIndex(e => e.UsageTimestamp)
            .HasDatabaseName("ix_usage_logs_usage_timestamp");
        // Index on data_source for filtering by integration path
        builder.HasIndex(e => e.DataSource)
            .HasDatabaseName("ix_usage_logs_data_source");
        // Relationships
        builder.HasOne(e => e.Spool)
            .WithMany()
            .HasForeignKey(e => e.SpoolId)
            .HasConstraintName("fk_usage_logs_spool")
            .OnDelete(DeleteBehavior.Restrict);
        builder.HasOne(e => e.Printer)
            .WithMany()
            .HasForeignKey(e => e.PrinterId)
            .HasConstraintName("fk_usage_logs_printer")
            .OnDelete(DeleteBehavior.SetNull);
        builder.HasOne(e => e.PrintJob)
            .WithMany()
            .HasForeignKey(e => e.PrintJobId)
            .HasConstraintName("fk_usage_logs_print_job")
            .OnDelete(DeleteBehavior.SetNull);
    }
 }
--- a/backend/Infrastructure/Data/ExtrudexDbContext.cs
+++ b/backend/Infrastructure/Data/ExtrudexDbContext.cs
@@ -1,79 +1 @@
 using Extrudex.Domain.Base;
 using Extrudex.Domain.Entities;
 using Microsoft.EntityFrameworkCore;
 namespace Extrudex.Infrastructure.Data;
 /// <summary>
 /// Main EF Core database context for the Extrudex system.
 /// Handles entity registration, snake_case naming, and automatic timestamp management.
 /// </summary>
 public class ExtrudexDbContext : DbContext
 {
    public ExtrudexDbContext(DbContextOptions<ExtrudexDbContext> options) : base(options) { }
    // Lookup tables
    public DbSet<MaterialBase> MaterialBases => Set<MaterialBase>();
    public DbSet<MaterialFinish> MaterialFinishes => Set<MaterialFinish>();
    public DbSet<MaterialModifier> MaterialModifiers => Set<MaterialModifier>();
    // Core entities
    public DbSet<Spool> Spools => Set<Spool>();
    public DbSet<Printer> Printers => Set<Printer>();
    public DbSet<AmsUnit> AmsUnits => Set<AmsUnit>();
    public DbSet<AmsSlot> AmsSlots => Set<AmsSlot>();
    public DbSet<PrintJob> PrintJobs => Set<PrintJob>();
    public DbSet<FilamentUsage> FilamentUsages => Set<FilamentUsage>();
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        // Apply all entity type configurations from the assembly
        modelBuilder.ApplyConfigurationsFromAssembly(typeof(ExtrudexDbContext).Assembly);
        // Apply seed data
        modelBuilder.Entity<MaterialBase>().HasData(SeedData.MaterialBases);
        modelBuilder.Entity<MaterialFinish>().HasData(SeedData.MaterialFinishes);
        modelBuilder.Entity<MaterialModifier>().HasData(SeedData.MaterialModifiers);
    }
    /// <summary>
    /// Automatically set UpdatedAt on auditable entities during SaveChanges.
    /// </summary>
    public override int SaveChanges(bool acceptAllChangesOnSuccess)
    {
        SetAuditTimestamps();
        return base.SaveChanges(acceptAllChangesOnSuccess);
    }
    public override async Task<int> SaveChangesAsync(
        bool acceptAllChangesOnSuccess,
        CancellationToken cancellationToken = default)
    {
        SetAuditTimestamps();
        return await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
    }
    /// <summary>
    /// Sets UpdatedAt on all auditable entities that have been modified.
    /// Sets CreatedAt on all auditable entities that are being added.
    /// </summary>
    private void SetAuditTimestamps()
    {
        var entries = ChangeTracker.Entries<AuditableEntity>();
        foreach (var entry in entries)
        {
            if (entry.State == EntityState.Added)
            {
                entry.Entity.CreatedAt = DateTime.UtcNow;
                entry.Entity.UpdatedAt = DateTime.UtcNow;
            }
            else if (entry.State == EntityState.Modified)
            {
                entry.Entity.UpdatedAt = DateTime.UtcNow;
            }
        }
    }
 }
--- a/backend/Infrastructure/Data/Migrations/20260426184329_AddUsageLogTable.Designer.cs
+++ b/backend/Infrastructure/Data/Migrations/20260426184329_AddUsageLogTable.Designer.cs
--- a/backend/Infrastructure/Data/Migrations/20260426184329_AddUsageLogTable.cs
+++ b/backend/Infrastructure/Data/Migrations/20260426184329_AddUsageLogTable.cs
@@ -0,0 +1,534 @@
 using System;
 using Microsoft.EntityFrameworkCore.Migrations;
 #nullable disable
 namespace Extrudex.Infrastructure.Data.Migrations
 {
    /// <inheritdoc />
    public partial class AddUsageLogTable : Migration
    {
        /// <inheritdoc />
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "usage_logs",
                columns: table => new
                {
                    id = table.Column<Guid>(type: "uuid", nullable: false),
                    spool_id = table.Column<Guid>(type: "uuid", nullable: false),
                    printer_id = table.Column<Guid>(type: "uuid", nullable: true),
                    print_job_id = table.Column<Guid>(type: "uuid", nullable: true),
                    grams_used = table.Column<decimal>(type: "numeric(10,2)", precision: 10, scale: 2, nullable: false),
                    mm_extruded = table.Column<decimal>(type: "numeric(12,2)", precision: 12, scale: 2, nullable: true),
                    usage_timestamp = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
                    data_source = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
                    notes = table.Column<string>(type: "character varying(2000)", maxLength: 2000, nullable: true),
                    created_at = table.Column<DateTime>(type: "timestamp with time zone", nullable: false, defaultValueSql: "now() at time zone 'utc'"),
                    updated_at = table.Column<DateTime>(type: "timestamp with time zone", nullable: false, defaultValueSql: "now() at time zone 'utc'")
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_usage_logs", x => x.id);
                    table.ForeignKey(
                        name: "fk_usage_logs_print_job",
                        column: x => x.print_job_id,
                        principalTable: "print_jobs",
                        principalColumn: "id",
                        onDelete: ReferentialAction.SetNull);
                    table.ForeignKey(
                        name: "fk_usage_logs_printer",
                        column: x => x.printer_id,
                        principalTable: "printers",
                        principalColumn: "id",
                        onDelete: ReferentialAction.SetNull);
                    table.ForeignKey(
                        name: "fk_usage_logs_spool",
                        column: x => x.spool_id,
                        principalTable: "spools",
                        principalColumn: "id",
                        onDelete: ReferentialAction.Restrict);
                });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000001"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(6535), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(6535) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000002"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7016), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7016) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000003"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7027), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7028) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000004"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7034), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7035) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000005"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7042), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7042) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000006"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7049), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7049) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000001"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7291), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7292) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000002"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7453), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7453) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000003"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7461), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7461) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000004"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7468), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7468) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000005"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7474), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7474) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000006"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7480), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7481) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000007"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7487), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7487) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000008"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7493), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7493) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000009"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7500), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7500) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000010"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7507), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7507) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000011"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7513), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7513) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000012"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7519), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7520) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000013"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7526), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7526) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000014"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7532), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7532) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000015"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7538), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7539) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000001"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7690), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7690) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000002"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7838), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7838) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000003"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7846), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7846) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000004"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7853), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7853) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000005"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7859), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7859) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000006"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7865), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7866) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000007"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7872), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7872) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000008"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7878), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7879) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000009"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7885), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7885) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000010"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7891), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7891) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000011"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7898), new DateTime(2026, 4, 26, 18, 43, 28, 895, DateTimeKind.Utc).AddTicks(7898) });
            migrationBuilder.CreateIndex(
                name: "ix_usage_logs_data_source",
                table: "usage_logs",
                column: "data_source");
            migrationBuilder.CreateIndex(
                name: "ix_usage_logs_print_job_id",
                table: "usage_logs",
                column: "print_job_id");
            migrationBuilder.CreateIndex(
                name: "ix_usage_logs_printer_id",
                table: "usage_logs",
                column: "printer_id");
            migrationBuilder.CreateIndex(
                name: "ix_usage_logs_spool_id",
                table: "usage_logs",
                column: "spool_id");
            migrationBuilder.CreateIndex(
                name: "ix_usage_logs_usage_timestamp",
                table: "usage_logs",
                column: "usage_timestamp");
        }
        /// <inheritdoc />
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "usage_logs");
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000001"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1096), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1096) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000002"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1620), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1620) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000003"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1630), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1630) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000004"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1638), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1638) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000005"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1645), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1645) });
            migrationBuilder.UpdateData(
                table: "material_bases",
                keyColumn: "id",
                keyValue: new Guid("10000000-0000-0000-0000-000000000006"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1651), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1652) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000001"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1850), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(1850) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000002"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2041), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2041) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000003"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2049), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2049) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000004"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2055), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2056) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000005"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2062), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2062) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000006"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2068), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2068) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000007"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2075), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2075) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000008"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2081), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2081) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000009"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2100), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2100) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000010"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2107), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2107) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000011"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2113), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2113) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000012"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2120), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2120) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000013"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2126), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2126) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000014"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2132), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2133) });
            migrationBuilder.UpdateData(
                table: "material_finishes",
                keyColumn: "id",
                keyValue: new Guid("20000000-0000-0000-0000-000000000015"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2139), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2139) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000001"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2304), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2304) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000002"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2463), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2463) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000003"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2471), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2471) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000004"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2477), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2478) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000005"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2484), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2484) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000006"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2490), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2491) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000007"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2497), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2497) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000008"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2503), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2503) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000009"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2510), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2510) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000010"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2516), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2516) });
            migrationBuilder.UpdateData(
                table: "material_modifiers",
                keyColumn: "id",
                keyValue: new Guid("30000000-0000-0000-0000-000000000011"),
                columns: new[] { "created_at", "updated_at" },
                values: new object[] { new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2522), new DateTime(2026, 4, 26, 13, 14, 18, 745, DateTimeKind.Utc).AddTicks(2523) });
        }
    }
 }
--- a/backend/Infrastructure/Services/CostPerPrintService.cs
+++ b/backend/Infrastructure/Services/CostPerPrintService.cs
@@ -1,158 +0,0 @@
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 namespace Extrudex.Infrastructure.Services;
 /// <summary>
 /// Calculates the cost of goods sold (COGS) per print job using the spool's
 /// purchase price and the print job's derived grams consumed.
 ///
 /// Formula:
 ///   cost_per_gram = purchase_price / weight_total_grams
 ///   cost_per_print = grams_derived × cost_per_gram
 ///
 /// Handles missing data gracefully — if the spool has no purchase price or
 /// weight recorded, the result includes warnings and null cost fields
 /// instead of throwing exceptions.
 /// </summary>
 public class CostPerPrintService : ICostPerPrintService
 {
    private readonly ExtrudexDbContext _dbContext;
    private readonly ILogger<CostPerPrintService> _logger;
    /// <summary>
    /// Initializes a new instance of the <see cref="CostPerPrintService"/> class.
    /// </summary>
    /// <param name="dbContext">The database context for data access.</param>
    /// <param name="logger">The logger for diagnostic output.</param>
    public CostPerPrintService(ExtrudexDbContext dbContext, ILogger<CostPerPrintService> logger)
    {
        _dbContext = dbContext;
        _logger = logger;
    }
    /// <inheritdoc />
    public async Task<CostPerPrintResult> CalculateAsync(Guid printJobId, CancellationToken cancellationToken = default)
    {
        _logger.LogDebug("Calculating cost per print for job {PrintJobId}", printJobId);
        var job = await _dbContext.PrintJobs
            .Include(j => j.Spool)
            .ThenInclude(s => s!.MaterialBase)
            .FirstOrDefaultAsync(j => j.Id == printJobId, cancellationToken);
        if (job is null)
        {
            _logger.LogWarning("Print job {PrintJobId} not found for cost calculation", printJobId);
            return new CostPerPrintResult
            {
                PrintJobId = printJobId,
                Warnings = new List<string> { $"Print job with ID '{printJobId}' not found." }
            };
        }
        return BuildResult(job);
    }
    /// <inheritdoc />
    public async Task<IReadOnlyList<CostPerPrintResult>> CalculateBySpoolAsync(
        Guid spoolId, CancellationToken cancellationToken = default)
    {
        _logger.LogDebug("Calculating cost per print for all jobs on spool {SpoolId}", spoolId);
        var jobs = await _dbContext.PrintJobs
            .Include(j => j.Spool)
            .ThenInclude(s => s!.MaterialBase)
            .Where(j => j.SpoolId == spoolId)
            .OrderByDescending(j => j.CreatedAt)
            .ToListAsync(cancellationToken);
        if (jobs.Count == 0)
        {
            _logger.LogDebug("No print jobs found for spool {SpoolId}", spoolId);
            return Array.Empty<CostPerPrintResult>();
        }
        return jobs.Select(BuildResult).ToList();
    }
    /// <summary>
    /// Builds a <see cref="CostPerPrintResult"/> from a print job entity.
    /// Computes cost_per_gram and cost_per_print when all required data is available.
    /// Populates warnings when data is missing or incomplete.
    /// </summary>
    /// <param name="job">The print job entity with Spool navigation loaded.</param>
    /// <returns>A cost calculation result with breakdown and any warnings.</returns>
    private CostPerPrintResult BuildResult(Domain.Entities.PrintJob job)
    {
        var warnings = new List<string>();
        var spool = job.Spool;
        // Map what we always have
        var result = new CostPerPrintResult
        {
            PrintJobId = job.Id,
            PrintName = job.PrintName,
            SpoolId = job.SpoolId,
            SpoolSerial = spool?.SpoolSerial ?? string.Empty,
            MmExtruded = job.MmExtruded,
            GramsDerived = job.GramsDerived,
        };
        // Guard: spool must be loaded
        if (spool is null)
        {
            warnings.Add("Spool data is not available for this print job.");
            result.Warnings = warnings;
            return result;
        }
        // Capture purchase price
        result.PurchasePrice = spool.PurchasePrice;
        result.WeightTotalGrams = spool.WeightTotalGrams;
        // Check for missing purchase price
        if (!spool.PurchasePrice.HasValue)
        {
            warnings.Add(
                "Spool purchase price is not recorded. Cost calculation requires a purchase price on the spool.");
        }
        // Check for zero or negative weight — prevents division by zero
        if (spool.WeightTotalGrams <= 0)
        {
            warnings.Add(
                "Spool total weight is zero or not recorded. Cost calculation requires a positive weight_total_grams on the spool.");
        }
        // Check for zero grams derived
        if (job.GramsDerived <= 0)
        {
            warnings.Add(
                "Derived grams consumed is zero. Ensure mm_extruded, filament diameter, and material density are recorded for this print job.");
        }
        // If all data is present and valid, compute the cost
        if (spool.PurchasePrice.HasValue && spool.WeightTotalGrams > 0 && job.GramsDerived > 0)
        {
            var costPerGram = spool.PurchasePrice.Value / spool.WeightTotalGrams;
            result.CostPerGram = Math.Round(costPerGram, 6);
            result.CostPerPrint = Math.Round(job.GramsDerived * costPerGram, 4);
            _logger.LogDebug(
                "Cost calculated for job {PrintJobId}: {GramsDerived}g × {CostPerGram:C}/g = {CostPerPrint:C}",
                job.Id, job.GramsDerived, result.CostPerGram, result.CostPerPrint);
        }
        else
        {
            _logger.LogDebug(
                "Cost calculation incomplete for job {PrintJobId}: missing data (warnings: {WarningCount})",
                job.Id, warnings.Count);
        }
        result.Warnings = warnings;
        return result;
    }
 }
--- a/backend/Infrastructure/Services/FilamentUsageSyncService.cs
+++ b/backend/Infrastructure/Services/FilamentUsageSyncService.cs
@@ -1,139 +0,0 @@
 using Extrudex.Domain.Enums;
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 namespace Extrudex.Infrastructure.Configuration;
 /// <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.
 /// </summary>
 public class FilamentUsageSyncService : IFilamentUsageSyncService
 {
    private readonly ExtrudexDbContext _dbContext;
    private readonly IMoonrakerClient _moonrakerClient;
    private readonly ILogger<FilamentUsageSyncService> _logger;
    /// <summary>
    /// Creates a new FilamentUsageSyncService.
    /// </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="logger">Logger for diagnostic output.</param>
    public FilamentUsageSyncService(
        ExtrudexDbContext dbContext,
        IMoonrakerClient moonrakerClient,
        ILogger<FilamentUsageSyncService> logger)
    {
        _dbContext = dbContext;
        _moonrakerClient = moonrakerClient;
        _logger = logger;
    }
    /// <inheritdoc />
    public async Task<int> SyncAllAsync(CancellationToken cancellationToken = default)
    {
        _logger.LogInformation("Starting filament usage sync cycle");
        var printers = await _dbContext.Printers
            .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
            .Include(p => p.AmsUnits)
                .ThenInclude(u => u.Slots)
                    .ThenInclude(s => s.Spool)
            .ToListAsync(cancellationToken);
        if (printers.Count == 0)
        {
            _logger.LogInformation("No active Moonraker printers found — skipping sync");
            return 0;
        }
        _logger.LogInformation("Found {PrinterCount} active Moonraker printer(s) to sync", printers.Count);
        var syncedCount = 0;
        foreach (var printer in printers)
        {
            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;
                syncedCount++;
                _logger.LogInformation(
                    "Successfully synced filament usage from printer {PrinterName}",
                    printer.Name);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "Error syncing filament usage from printer {PrinterName} ({Host}:{Port})",
                    printer.Name, printer.HostnameOrIp, printer.Port);
            }
        }
        await _dbContext.SaveChangesAsync(cancellationToken);
        _logger.LogInformation(
            "Filament usage sync cycle complete — {SyncedCount}/{TotalCount} printers synced",
            syncedCount, printers.Count);
        return syncedCount;
    }
    /// <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,
        Dictionary<string, decimal> usageData)
    {
        // Update AMS slot remaining weights if available
        foreach (var amsUnit in printer.AmsUnits)
        {
            foreach (var slot in amsUnit.Slots)
            {
                if (slot.Spool != null && slot.RemainingWeightG.HasValue)
                {
                    // Sync the AMS-reported remaining weight to the spool
                    slot.Spool.WeightRemainingGrams = slot.RemainingWeightG.Value;
                    _logger.LogDebug(
                        "Updated spool {SpoolSerial} remaining weight to {Weight}g",
                        slot.Spool.SpoolSerial, slot.RemainingWeightG.Value);
                }
            }
        }
        // If usage data contains extruded mm, log it for observability
        if (usageData.TryGetValue("mm_extruded", out var mmExtruded) && mmExtruded > 0)
        {
            _logger.LogInformation(
                "Printer {PrinterName} reports {MmExtruded}mm filament extruded in latest job",
                printer.Name, mmExtruded);
        }
    }
 }
--- a/backend/Infrastructure/Services/MoonrakerClient.cs
+++ b/backend/Infrastructure/Services/MoonrakerClient.cs
@@ -1,130 +0,0 @@
 using System.Net.Http.Json;
 using System.Text.Json;
 using Extrudex.Domain.Interfaces;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 namespace Extrudex.Infrastructure.Configuration;
 /// <summary>
 /// HTTP client for communicating with Moonraker REST API endpoints
 /// on Klipper-based printers (e.g., Elegoo Centauri Carbon).
 /// Retrieves filament usage data and printer status information.
 /// </summary>
 public class MoonrakerClient : IMoonrakerClient
 {
    private readonly HttpClient _httpClient;
    private readonly ILogger<MoonrakerClient> _logger;
    /// <summary>
    /// Creates a new MoonrakerClient with the configured HTTP client and logger.
    /// </summary>
    /// <param name="httpClient">The HTTP client for making requests to Moonraker endpoints.</param>
    /// <param name="logger">Logger for diagnostic output.</param>
    public MoonrakerClient(HttpClient httpClient, ILogger<MoonrakerClient> logger)
    {
        _httpClient = httpClient;
        _logger = logger;
    }
    /// <inheritdoc />
    public async Task<Dictionary<string, decimal>> GetFilamentUsageAsync(
        string hostnameOrIp,
        int port,
        string? apiKey,
        CancellationToken cancellationToken = default)
    {
        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
        var result = new Dictionary<string, decimal>();
        try
        {
            // Query Moonraker server info endpoint for filament usage data
            using var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}/server/history/items?limit=1");
            if (!string.IsNullOrEmpty(apiKey))
            {
                request.Headers.Add("X-Api-Key", apiKey);
            }
            using var response = await _httpClient.SendAsync(request, cancellationToken);
            response.EnsureSuccessStatusCode();
            var json = await response.Content.ReadFromJsonAsync<JsonElement>(cancellationToken: cancellationToken);
            // Extract filament usage from the response
            // Moonraker returns job history with filament_used and similar fields
            if (json.TryGetProperty("result", out var resultElement))
            {
                if (resultElement.TryGetProperty("items", out var items) && items.GetArrayLength() > 0)
                {
                    var job = items[0];
                    // Moonraker tracks filament_used in millimeters
                    if (job.TryGetProperty("filament_used", out var filamentUsed))
                    {
                        result["mm_extruded"] = filamentUsed.GetDecimal();
                    }
                    // Total duration in seconds
                    if (job.TryGetProperty("print_duration", out var duration))
                    {
                        result["print_duration_seconds"] = duration.GetDecimal();
                    }
                }
            }
            _logger.LogDebug(
                "Retrieved filament usage from Moonraker at {Host}:{Port}: {MetricCount} metrics",
                hostnameOrIp, port, result.Count);
        }
        catch (HttpRequestException ex)
        {
            _logger.LogWarning(ex,
                "Failed to retrieve filament usage from Moonraker at {Host}:{Port}",
                hostnameOrIp, port);
        }
        catch (JsonException ex)
        {
            _logger.LogWarning(ex,
                "Failed to parse Moonraker response from {Host}:{Port}",
                hostnameOrIp, port);
        }
        return result;
    }
    /// <inheritdoc />
    public async Task<bool> IsReachableAsync(
        string hostnameOrIp,
        int port,
        string? apiKey,
        CancellationToken cancellationToken = default)
    {
        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
        try
        {
            using var request = new HttpRequestMessage(HttpMethod.Get, $"{baseUrl}/server/info");
            if (!string.IsNullOrEmpty(apiKey))
            {
                request.Headers.Add("X-Api-Key", apiKey);
            }
            using var response = await _httpClient.SendAsync(request, cancellationToken);
            return response.IsSuccessStatusCode;
        }
        catch (HttpRequestException)
        {
            _logger.LogDebug("Moonraker at {Host}:{Port} is not reachable", hostnameOrIp, port);
            return false;
        }
    }
    /// <summary>
    /// Builds the base URL for Moonraker API calls from hostname and port.
    /// </summary>
    private static string BuildBaseUrl(string hostnameOrIp, int port)
    {
        return $"http://{hostnameOrIp}:{port}";
    }
 }
--- a/backend/Infrastructure/Services/UsageLogService.cs
+++ b/backend/Infrastructure/Services/UsageLogService.cs
@@ -0,0 +1,81 @@
 using Extrudex.Domain.Entities;
 using Extrudex.Domain.Enums;
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 namespace Extrudex.Infrastructure.Services;
 /// <summary>
 /// Implementation of <see cref="IUsageLogService"/> that persists usage entries
 /// to the usage_logs table via EF Core.
 /// </summary>
 public class UsageLogService : IUsageLogService
 {
    private readonly ExtrudexDbContext _dbContext;
    /// <summary>
    /// Initializes a new instance of the <see cref="UsageLogService"/> class.
    /// </summary>
    /// <param name="dbContext">The EF Core database context for data persistence.</param>
    public UsageLogService(ExtrudexDbContext dbContext)
    {
        _dbContext = dbContext;
    }
    /// <inheritdoc/>
    public async Task<UsageLog> RecordUsageAsync(
        Guid spoolId,
        decimal gramsUsed,
        DataSource dataSource,
        Guid? printerId = null,
        Guid? printJobId = null,
        decimal? mmExtruded = null,
        DateTime? usageTimestamp = null,
        string? notes = null)
    {
        var entry = new UsageLog
        {
            SpoolId = spoolId,
            GramsUsed = gramsUsed,
            DataSource = dataSource,
            PrinterId = printerId,
            PrintJobId = printJobId,
            MmExtruded = mmExtruded,
            UsageTimestamp = usageTimestamp ?? DateTime.UtcNow,
            Notes = notes
        };
        _dbContext.UsageLogs.Add(entry);
        await _dbContext.SaveChangesAsync();
        return entry;
    }
    /// <inheritdoc/>
    public async Task<IEnumerable<UsageLog>> GetBySpoolAsync(Guid spoolId, CancellationToken cancellationToken = default)
    {
        return await _dbContext.UsageLogs
            .Where(u => u.SpoolId == spoolId)
            .OrderByDescending(u => u.UsageTimestamp)
            .ToListAsync(cancellationToken);
    }
    /// <inheritdoc/>
    public async Task<IEnumerable<UsageLog>> GetByPrinterAsync(Guid printerId, CancellationToken cancellationToken = default)
    {
        return await _dbContext.UsageLogs
            .Where(u => u.PrinterId == printerId)
            .OrderByDescending(u => u.UsageTimestamp)
            .ToListAsync(cancellationToken);
    }
    /// <inheritdoc/>
    public async Task<IEnumerable<UsageLog>> GetByPrintJobAsync(Guid printJobId, CancellationToken cancellationToken = default)
    {
        return await _dbContext.UsageLogs
            .Where(u => u.PrintJobId == printJobId)
            .OrderByDescending(u => u.UsageTimestamp)
            .ToListAsync(cancellationToken);
    }
 }
--- a/backend/Program.cs
+++ b/backend/Program.cs
@@ -1,9 +1,7 @@
 using System.Reflection;
 using Extrudex.API.Filters;
 using Extrudex.API.Hubs;
 using Extrudex.API.Jobs;
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Configuration;
 using Extrudex.Infrastructure.Data;
 using Extrudex.Infrastructure.Services;
 using FluentValidation;
@@ -52,8 +50,8 @@ builder.Services.AddSwaggerGen(c =>
 // ── QR Code Generation ──────────────────────────────────────
 builder.Services.AddSingleton<IQrCodeService, QrCodeService>();
-// ── Cost Per Print Calculation ─────────────────────────────
+// ── Usage Logging ───────────────────────────────────────────
-builder.Services.AddScoped<ICostPerPrintService, CostPerPrintService>();
+builder.Services.AddScoped<IUsageLogService, UsageLogService>();
 // ── FluentValidation ──────────────────────────────────────
 // Registers all validators from the API assembly into DI.
@@ -82,16 +80,6 @@ builder.Services.AddCors(options =>
 // ── SignalR (real-time printer updates) ────────────────────
 builder.Services.AddSignalR();
 // ── Filament Usage Sync (Background Job) ──────────────────
 builder.Services.Configure<FilamentUsageSyncOptions>(
    builder.Configuration.GetSection(FilamentUsageSyncOptions.SectionName));
 builder.Services.AddHttpClient<IMoonrakerClient, MoonrakerClient>(client =>
 {
    client.DefaultRequestHeaders.Add("User-Agent", "Extrudex/1.0");
 });
 builder.Services.AddScoped<IFilamentUsageSyncService, FilamentUsageSyncService>();
 builder.Services.AddHostedService<FilamentUsageSyncJob>();
 // ── Health Checks ───────────────────────────────────────────
 builder.Services.AddHealthChecks()
    .AddNpgSql(connectionString);
--- a/backend/appsettings.Development.json
+++ b/backend/appsettings.Development.json
@@ -8,10 +8,5 @@
  },
  "ConnectionStrings": {
    "ExtrudexDb": "Host=localhost;Port=5432;Database=extrudex_dev;Username=extrudex;Password=changeme"
  },
  "FilamentUsageSync": {
    "PollingInterval": "00:01:00",
    "RequestTimeout": "00:00:30",
    "Enabled": true
  }
 }
--- a/backend/appsettings.json
+++ b/backend/appsettings.json
@@ -9,10 +9,5 @@
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "ExtrudexDb": "Host=localhost;Port=5432;Database=extrudex;Username=extrudex;Password=changeme"
  },
  "FilamentUsageSync": {
    "PollingInterval": "00:05:00",
    "RequestTimeout": "00:00:30",
    "Enabled": true
  }
 }
--- a/deploy.sh
+++ b/deploy.sh
@@ -18,14 +18,13 @@ echo "📦 Building and starting services..."
 $COMPOSE_CMD -f docker-compose.dev.yml up -d --build
 echo "⏳ Waiting for services to become healthy..."
-sleep 15
+sleep 10
 echo "✅ Deployment complete!"
 echo ""
 echo "Services running:"
 echo "  • PostgreSQL:    localhost:5433"
 echo "  • Extrudex API: http://localhost:5080"
-echo "  • Extrudex Web: http://localhost:5081"
+echo "  • Control Center Web: http://localhost:5081"
 echo ""
 echo "To view logs:"
 echo "  $COMPOSE_CMD -f docker-compose.dev.yml logs -f"
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -1,25 +1,6 @@
-services:
+version: '3.8'
  extrudex-db:
    image: postgres:16-alpine
    container_name: extrudex-db
    environment:
      POSTGRES_USER: extrudex
      POSTGRES_PASSWORD: changeme
      POSTGRES_DB: extrudex
    ports:
      - "5433:5432"
    volumes:
      - extrudex-db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U extrudex"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    restart: unless-stopped
    networks:
      - extrudex-network
 services:
  extrudex-api:
    build:
      context: ./backend
@@ -30,14 +11,6 @@ services:
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - ASPNETCORE_URLS=http://+:8080
      - EXTRUDEX_DB_HOST=extrudex-db
      - EXTRUDEX_DB_PORT=5432
      - EXTRUDEX_DB_NAME=extrudex
      - EXTRUDEX_DB_USER=extrudex
      - EXTRUDEX_DB_PASSWORD=changeme
    depends_on:
      extrudex-db:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
@@ -48,11 +21,11 @@ services:
    networks:
      - extrudex-network
-  extrudex-web:
+  control-center-web:
    build:
-      context: ./frontend
+      context: ../Control-Center/frontend
      dockerfile: Dockerfile
-    container_name: extrudex-web
+    container_name: control-center-web
    ports:
      - "5081:80"
    depends_on:
@@ -62,9 +35,6 @@ services:
    networks:
      - extrudex-network
 volumes:
  extrudex-db-data:
 networks:
  extrudex-network:
    driver: bridge
--- a/frontend/src/app/components/filament-filter/filament-filter.component.html
+++ b/frontend/src/app/components/filament-filter/filament-filter.component.html
@@ -1,76 +0,0 @@
 <!-- Filament Filter Bar — material type, color search, low stock, active-only -->
 <div class="filament-filter-bar" role="search" aria-label="Filter filament inventory">
  <!-- Material Type Multi-Select -->
  <mat-form-field appearance="outline" class="filter-field material-filter">
    <mat-label>Material</mat-label>
    <mat-select multiple
                [value]="selectedMaterials()"
                (selectionChange)="onMaterialChange($event.value)"
                aria-label="Filter by material type">
      @for (material of materialOptions(); track material) {
        <mat-option [value]="material">{{ material }}</mat-option>
      }
    </mat-select>
    @if (selectedMaterials().length > 0) {
      <mat-chip-set class="selected-chips" matSuffix>
        @for (mat of selectedMaterials(); track mat) {
          <mat-chip (removed)="removeMaterial(mat)"
                    class="filter-chip">
            <span>{{ mat }}</span>
            <mat-icon matChipRemove>cancel</mat-icon>
          </mat-chip>
        }
      </mat-chip-set>
    }
  </mat-form-field>
  <!-- Color Search -->
  <mat-form-field appearance="outline" class="filter-field color-filter">
    <mat-label>Color</mat-label>
    <input matInput
           type="text"
           [value]="colorSearch()"
           (input)="onColorSearchChange($any($event.target).value)"
           placeholder="Search color..."
           aria-label="Filter by color name" />
    @if (colorSearch().trim()) {
      <mat-icon matSuffix class="filter-active-icon">filter_list</mat-icon>
    }
  </mat-form-field>
  <!-- Low Stock Toggle -->
  <mat-checkbox [checked]="lowStockOnly()"
                (change)="onLowStockToggle($event.checked)"
                class="filter-checkbox"
                aria-label="Show low stock only"
                matTooltip="Show only spools at 25% or less remaining"
                matTooltipPosition="below">
    <mat-icon class="checkbox-icon" [class.active]="lowStockOnly()">warning</mat-icon>
    Low Stock
  </mat-checkbox>
  <!-- Active Only Toggle -->
  <mat-checkbox [checked]="activeOnly()"
                (change)="onActiveOnlyToggle($event.checked)"
                class="filter-checkbox"
                aria-label="Show active spools only"
                matTooltip="Show only spools currently in use"
                matTooltipPosition="below">
    <mat-icon class="checkbox-icon" [class.active]="activeOnly()">check_circle</mat-icon>
    Active Only
  </mat-checkbox>
  <!-- Clear All Filters -->
  @if (hasActiveFilters()) {
    <button mat-button
            class="clear-filters-btn"
            (click)="clearAll()"
            aria-label="Clear all filters"
            matTooltip="Remove all filters"
            matTooltipPosition="below">
      <mat-icon>filter_alt_off</mat-icon>
      Clear
    </button>
  }
 </div>
--- a/frontend/src/app/components/filament-filter/filament-filter.component.scss
+++ b/frontend/src/app/components/filament-filter/filament-filter.component.scss
@@ -1,134 +0,0 @@
 /**
 * Filament Filter Bar Styles
 * Responsive filter layout for kiosk and mobile
 */
 $spacing-unit: 8px;
 .filament-filter-bar {
  display: flex;
  align-items: center;
  gap: $spacing-unit * 2;
  flex-wrap: wrap;
  padding: $spacing-unit * 2 0;
  margin-bottom: $spacing-unit * 2;
 }
 // Form field sizing
 .filter-field {
  flex: 0 1 auto;
  min-width: 160px;
  &.material-filter {
    min-width: 200px;
  }
  &.color-filter {
    min-width: 180px;
  }
  // Reduce vertical spacing inside filter fields
  .mat-mdc-form-field-subscript-wrapper {
    display: none; // No hint/error text needed for filters
  }
 }
 // Selected material chips
 .selected-chips {
  flex-wrap: wrap;
  gap: 4px;
 }
 .filter-chip {
  font-size: 12px !important;
  min-height: 24px !important;
  mat-icon {
    font-size: 14px !important;
    width: 14px !important;
    height: 14px !important;
  }
 }
 // Active filter icon
 .filter-active-icon {
  color: var(--mat-sys-primary);
  font-size: 18px !important;
  width: 18px !important;
  height: 18px !important;
 }
 // Checkbox styling
 .filter-checkbox {
  display: flex;
  align-items: center;
  gap: 4px;
  white-space: nowrap;
  user-select: none;
  touch-action: manipulation; // Prevent zoom on double-tap
  .checkbox-icon {
    font-size: 18px !important;
    width: 18px !important;
    height: 18px !important;
    color: var(--mat-sys-on-surface-variant);
    transition: color 0.2s ease;
    &.active {
      color: var(--mat-sys-primary);
    }
  }
 }
 // Clear filters button
 .clear-filters-btn {
  display: flex;
  align-items: center;
  gap: 4px;
  font-size: 13px;
  mat-icon {
    font-size: 18px !important;
    width: 18px !important;
    height: 18px !important;
  }
 }
 // Responsive: stack filters vertically on small screens
@media (max-width: 768px) {
  .filament-filter-bar {
    flex-direction: column;
    align-items: stretch;
    gap: $spacing-unit;
  }
  .filter-field {
    width: 100%;
    min-width: unset;
    &.material-filter,
    &.color-filter {
      min-width: unset;
    }
  }
  .filter-checkbox {
    padding: $spacing-unit 0;
  }
  .clear-filters-btn {
    align-self: flex-start;
  }
 }
 // Extra-small screens (phone portrait)
@media (max-width: 480px) {
  .filament-filter-bar {
    padding: $spacing-unit 0;
    margin-bottom: $spacing-unit;
  }
  .filter-checkbox {
    font-size: 13px;
  }
 }
--- a/frontend/src/app/components/filament-filter/filament-filter.component.ts
+++ b/frontend/src/app/components/filament-filter/filament-filter.component.ts
@@ -1,158 +0,0 @@
 import {
  ChangeDetectionStrategy,
  Component,
  EventEmitter,
  Input,
  Output,
  computed,
  signal,
 } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
 import { MatFormFieldModule } from '@angular/material/form-field';
 import { MatSelectModule } from '@angular/material/select';
 import { MatInputModule } from '@angular/material/input';
 import { MatCheckboxModule } from '@angular/material/checkbox';
 import { MatIconModule } from '@angular/material/icon';
 import { MatChipsModule } from '@angular/material/chips';
 import { MatButtonModule } from '@angular/material/button';
 import { MatTooltipModule } from '@angular/material/tooltip';
 import {
  Filament,
  StockLevel,
  classifyStockLevel,
 } from '../../models/filament.model';
 /** Filter state emitted by the filament filter component */
 export interface FilamentFilterState {
  /** Selected material base names — empty means all */
  materialBaseNames: string[];
  /** Color search text — empty string means all */
  colorSearch: string;
  /** Whether to show only low/critical stock */
  lowStockOnly: boolean;
  /** Whether to show only active spools */
  activeOnly: boolean;
 }
 /**
 * FilamentFilterComponent — Filter bar for the filament inventory list.
 *
 * Provides:
 * - Material type multi-select filter
 * - Color name text search
 * - Low stock toggle (shows only critical/low spools)
 * - Active-only toggle
 * - Clear all filters action
 */
@Component({
  selector: 'app-filament-filter',
  standalone: true,
  imports: [
    CommonModule,
    FormsModule,
    MatFormFieldModule,
    MatSelectModule,
    MatInputModule,
    MatCheckboxModule,
    MatIconModule,
    MatChipsModule,
    MatButtonModule,
    MatTooltipModule,
  ],
  templateUrl: './filament-filter.component.html',
  styleUrl: './filament-filter.component.scss',
  changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class FilamentFilterComponent {
  /** Filament data input — used to derive material options */
  @Input() set filaments(value: Filament[]) {
    this._filaments.set(value);
    const materials = [...new Set(value.map((f) => f.materialBaseName))].sort();
    this.materialOptions.set(materials);
  }
  get filaments(): Filament[] {
    return this._filaments();
  }
  private readonly _filaments = signal<Filament[]>([]);
  /** Available material base names derived from filament data */
  readonly materialOptions = signal<string[]>([]);
  /** Selected material base names */
  readonly selectedMaterials = signal<string[]>([]);
  /** Color search text */
  readonly colorSearch = signal('');
  /** Low stock only toggle */
  readonly lowStockOnly = signal(false);
  /** Active only toggle */
  readonly activeOnly = signal(false);
  /** Computed: whether any filters are active */
  readonly hasActiveFilters = computed(
    () =>
      this.selectedMaterials().length > 0 ||
      this.colorSearch().trim().length > 0 ||
      this.lowStockOnly() ||
      this.activeOnly()
  );
  /** Emits the current filter state whenever filters change */
  @Output() readonly filterChange = new EventEmitter<FilamentFilterState>();
  /** Handle material selection change */
  onMaterialChange(selected: string[]): void {
    this.selectedMaterials.set(selected);
    this.emitFilterState();
  }
  /** Handle color search input */
  onColorSearchChange(value: string): void {
    this.colorSearch.set(value);
    this.emitFilterState();
  }
  /** Handle low stock toggle */
  onLowStockToggle(checked: boolean): void {
    this.lowStockOnly.set(checked);
    this.emitFilterState();
  }
  /** Handle active-only toggle */
  onActiveOnlyToggle(checked: boolean): void {
    this.activeOnly.set(checked);
    this.emitFilterState();
  }
  /** Remove a single material chip */
  removeMaterial(material: string): void {
    const updated = this.selectedMaterials().filter((m) => m !== material);
    this.selectedMaterials.set(updated);
    this.emitFilterState();
  }
  /** Clear all filters */
  clearAll(): void {
    this.selectedMaterials.set([]);
    this.colorSearch.set('');
    this.lowStockOnly.set(false);
    this.activeOnly.set(false);
    this.emitFilterState();
  }
  /** Emit the current filter state */
  private emitFilterState(): void {
    this.filterChange.emit({
      materialBaseNames: this.selectedMaterials(),
      colorSearch: this.colorSearch().trim().toLowerCase(),
      lowStockOnly: this.lowStockOnly(),
      activeOnly: this.activeOnly(),
    });
  }
 }
--- a/frontend/src/app/components/filament-table/filament-table.component.html
+++ b/frontend/src/app/components/filament-table/filament-table.component.html
@@ -1,12 +1,6 @@
-<!-- Filament Inventory Table — with filters and low stock indicators -->
+<!-- Filament Inventory Table — with low stock indicators -->
 <div class="filament-table-container" role="region" aria-label="Filament inventory">
  <!-- Filter Bar -->
  <app-filament-filter
    [filaments]="allFilaments()"
    (filterChange)="onFilterChange($event)"
    aria-label="Filter filament inventory" />
  <!-- Low Stock Alert Banner — shown when critical or low stock spools exist -->
  @if (criticalCount() > 0) {
    <div class="alert-banner critical" role="alert">
@@ -22,7 +16,7 @@
  <!-- Filament Table -->
  <table mat-table
-         [dataSource]="filteredFilaments()"
+         [dataSource]="sortedFilaments()"
         matSort
         (matSortChange)="sortData($event)"
         class="filament-table"
@@ -119,15 +113,7 @@
    </tr>
  </table>
-  <!-- Filtered empty state -->
+  <!-- Empty state -->
  @if (filteredFilaments().length === 0 && filaments().length > 0) {
    <div class="empty-state" role="status">
      <mat-icon aria-hidden="true">filter_alt_off</mat-icon>
      <p>No filaments match the current filters</p>
    </div>
  }
  <!-- No data empty state -->
  @if (filaments().length === 0) {
    <div class="empty-state" role="status">
      <mat-icon aria-hidden="true">inventory_2</mat-icon>
--- a/frontend/src/app/components/filament-table/filament-table.component.ts
+++ b/frontend/src/app/components/filament-table/filament-table.component.ts
@@ -12,7 +12,6 @@ import { MatIconModule } from '@angular/material/icon';
 import { MatProgressBarModule } from '@angular/material/progress-bar';
 import { MatTooltipModule } from '@angular/material/tooltip';
 import { MatSortModule, Sort } from '@angular/material/sort';
 import { FilamentFilterComponent, FilamentFilterState } from '../filament-filter/filament-filter.component';
 import {
  Filament,
  StockLevel,
@@ -41,7 +40,6 @@ export type FilamentColumn =
    MatProgressBarModule,
    MatTooltipModule,
    MatSortModule,
    FilamentFilterComponent,
  ],
  templateUrl: './filament-table.component.html',
  styleUrl: './filament-table.component.scss',
@@ -72,24 +70,9 @@ export class FilamentTableComponent {
  /** Default columns for template binding */
  readonly columns = this._displayedColumns;
  /** Current filter state */
  readonly filterState = signal<FilamentFilterState>({
    materialBaseNames: [],
    colorSearch: '',
    lowStockOnly: false,
    activeOnly: false,
  });
  /** Sorted filament data */
  readonly sortedFilaments = signal<Filament[]>([]);
  /** Computed: filtered + sorted filament data for display */
  readonly filteredFilaments = computed(() => {
    const data = this.sortedFilaments();
    const filters = this.filterState();
    return data.filter((f) => this.matchesFilter(f, filters));
  });
  /** Computed: count of low/critical spools */
  readonly lowStockCount = computed(() =>
    this.filaments().filter(
@@ -228,9 +211,6 @@ export class FilamentTableComponent {
    this.sortedFilaments.set([...data]);
  }
  /** All filament data — for the filter component to derive material options */
  readonly allFilaments = this.filaments;
  /** Handle sort changes from MatSort */
  sortData(sort: Sort): void {
    const data = [...this.filaments()];
@@ -272,46 +252,6 @@ export class FilamentTableComponent {
    this.sortedFilaments.set(sorted);
  }
  /** Handle filter changes from FilamentFilterComponent */
  onFilterChange(state: FilamentFilterState): void {
    this.filterState.set(state);
  }
  /** Check if a filament matches the current filter state */
  private matchesFilter(filament: Filament, filters: FilamentFilterState): boolean {
    // Material filter — empty means all
    if (
      filters.materialBaseNames.length > 0 &&
      !filters.materialBaseNames.includes(filament.materialBaseName)
    ) {
      return false;
    }
    // Color search — empty means all
    if (
      filters.colorSearch &&
      !filament.colorName.toLowerCase().includes(filters.colorSearch) &&
      !filament.colorHex.toLowerCase().includes(filters.colorSearch)
    ) {
      return false;
    }
    // Low stock filter — show only critical/low
    if (filters.lowStockOnly) {
      const level = classifyStockLevel(filament);
      if (level !== 'critical' && level !== 'low') {
        return false;
      }
    }
    // Active only filter
    if (filters.activeOnly && !filament.isActive) {
      return false;
    }
    return true;
  }
  /** Template helper: get remaining percent */
  getRemainingPercent = getRemainingPercent;
Author	SHA1	Message	Date
rex-bot	6aeb344d3f	merge(dev): Re-apply changes after conflict resolution Some checks failed Dev Build / build-test (pull_request) Failing after 1m0s Details Dev Build / deploy-dev (pull_request) Has been skipped Details Dev Build / notify-success (pull_request) Has been skipped Details Dev Build / notify-failure (pull_request) Successful in 4s Details	2026-04-27 18:16:43 -04:00
rex-bot	e0e4fabaed	Merge remote-tracking branch 'origin/dev' into fix-pr-11 # Conflicts: # backend/Program.cs	2026-04-27 18:16:43 -04:00
dex-bot	432ce39e62	Merge remote-tracking branch 'origin/dev' into agent/dex/CUB-32-usage-logging-service Some checks failed Dev Build / build-test (pull_request) Failing after 55s Details Dev Build / deploy-dev (pull_request) Has been skipped Details Dev Build / notify-success (pull_request) Has been skipped Details Dev Build / notify-failure (pull_request) Successful in 4s Details # Conflicts: # backend/Infrastructure/Data/ExtrudexDbContext.cs # backend/Infrastructure/Data/Migrations/ExtrudexDbContextModelSnapshot.cs	2026-04-27 14:29:13 -04:00
rex-bot	42e90f028a	CUB-32: Add usage logging service with EF Core entity, service, controller, and migration Some checks failed Dev Build / build-test (pull_request) Failing after 58s Details Dev Build / deploy-dev (pull_request) Has been skipped Details Dev Build / notify-success (pull_request) Has been skipped Details Dev Build / notify-failure (pull_request) Successful in 3s Details	2026-04-26 18:44:02 +00:00