CubeCraft-Creations/Extrudex
9
0
Fork 0
Code Issues Pull Requests 7 Actions Packages Projects Releases Wiki Activity

merge(dev): Re-apply changes after conflict resolution
Some checks failed
Dev Build / build-test (pull_request) Failing after 1m9s
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

Browse Source
This commit is contained in:
rex-bot
2026-04-27 18:16:47 -04:00
parent d3c1b929c5
commit e209c3891e
29 changed files with 784 additions and 1305 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
backend/API/Controllers/CostAnalysisController.cs
View File

@@ -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
};
}

99
backend/API/DTOs/PrintJobs/CostPerPrintDtos.cs
View File

@@ -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();
}

79
backend/API/Jobs/FilamentUsageSyncJob.cs
View File

@@ -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");
}
}

3
backend/Dockerfile
View File

@@ -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

76
backend/Domain/Interfaces/ICostPerPrintService.cs
View File

@@ -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();
}

19
backend/Domain/Interfaces/IFilamentUsageSyncService.cs
View File

@@ -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);
}

75
backend/Domain/Interfaces/IMoonrakerClient.cs
View File

@@ -1,39 +1,76 @@
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.
/// Client for communicating with Moonraker REST API on Klipper-based printers
/// (e.g., Elegoo Centauri Carbon). Retrieves print job metadata including
/// filament usage data.
/// </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.
/// Retrieves the current printer status from Moonraker.
/// </summary>
/// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
/// <param name="port">The Moonraker API port (default: 7125).</param>
/// <param name="hostnameOrIp">Printer hostname or IP address.</param>
/// <param name="port">Moonraker 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(
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>The printer status string (e.g., "idle", "printing", "paused", "error").</returns>
Task<string> GetPrinterStatusAsync(
string hostnameOrIp,
int port,
string? apiKey,
string? apiKey = null,
CancellationToken cancellationToken = default);
/// <summary>
/// Checks whether the Moonraker server is reachable and responding.
/// Retrieves filament usage data from the current or most recent print job.
/// Moonraker exposes this via the /api/objects endpoint querying
/// "history" and "print_stats" objects.
/// </summary>
/// <param name="hostnameOrIp">The printer's hostname or IP address.</param>
/// <param name="port">The Moonraker API port (default: 7125).</param>
/// <param name="hostnameOrIp">Printer hostname or IP address.</param>
/// <param name="port">Moonraker 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(
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns> Filament usage data from Moonraker, or null if unavailable.</returns>
Task<MoonrakerFilamentUsage?> GetFilamentUsageAsync(
string hostnameOrIp,
int port,
string? apiKey,
string? apiKey = null,
CancellationToken cancellationToken = default);
}
/// <summary>
/// Represents filament usage data retrieved from a Moonraker-equipped printer.
/// Maps to Moonraker's print_stats and history objects.
/// </summary>
public class MoonrakerFilamentUsage
{
/// <summary>
/// Millimeters of filament extruded during the print job.
/// </summary>
public decimal MmExtruded { get; set; }
/// <summary>
/// The filename of the G-code file being or recently printed.
/// </summary>
public string? GcodeFileName { get; set; }
/// <summary>
/// Current print state from Moonraker (e.g., "printing", "complete", "error").
/// </summary>
public string PrintState { get; set; } = string.Empty;
/// <summary>
/// Total print time in seconds, if available from Moonraker.
/// </summary>
public double? PrintDurationSeconds { get; set; }
/// <summary>
/// Timestamp (UTC) when the print job was started, if available.
/// </summary>
public DateTime? StartedAt { get; set; }
/// <summary>
/// Timestamp (UTC) when the print job completed, if available.
/// </summary>
public DateTime? CompletedAt { get; set; }
}

33
backend/Infrastructure/Configuration/FilamentUsageSyncOptions.cs
View File

@@ -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;
}

158
backend/Infrastructure/Services/CostPerPrintService.cs
View File

@@ -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;
}
}

139
backend/Infrastructure/Services/FilamentUsageSyncService.cs
View File

@@ -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);
}
}
}

307
backend/Infrastructure/Services/MoonrakerClient.cs
View File

@@ -1,15 +1,20 @@
using System.Net.Http.Json;
using System.Globalization;
using System.Net.Http.Headers;
using System.Text.Json;
using Extrudex.Domain.Interfaces;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace Extrudex.Infrastructure.Configuration;
namespace Extrudex.Infrastructure.Services;
/// <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.
/// HTTP client for communicating with the Moonraker REST API on
/// Klipper-based printers (e.g., Elegoo Centauri Carbon).
///
/// Moonraker endpoints used:
/// - GET /api/objects?print_stats — current print stats including filament used
/// - GET /api/objects?history — job history with filament usage per job
///
/// Authentication: optional X-Api-Key header when API key is configured.
/// </summary>
public class MoonrakerClient : IMoonrakerClient
{
@@ -17,9 +22,9 @@ public class MoonrakerClient : IMoonrakerClient
private readonly ILogger<MoonrakerClient> _logger;
/// <summary>
/// Creates a new MoonrakerClient with the configured HTTP client and logger.
/// Creates a new MoonrakerClient with the specified HTTP client and logger.
/// </summary>
/// <param name="httpClient">The HTTP client for making requests to Moonraker endpoints.</param>
/// <param name="httpClient">The HTTP client used for API calls.</param>
/// <param name="logger">Logger for diagnostic output.</param>
public MoonrakerClient(HttpClient httpClient, ILogger<MoonrakerClient> logger)
{
@@ -28,103 +33,271 @@ public class MoonrakerClient : IMoonrakerClient
}
/// <inheritdoc />
public async Task<Dictionary<string, decimal>> GetFilamentUsageAsync(
public async Task<string> GetPrinterStatusAsync(
string hostnameOrIp,
int port,
string? apiKey,
string? apiKey = null,
CancellationToken cancellationToken = default)
{
var baseUrl = BuildBaseUrl(hostnameOrIp, port);
var result = new Dictionary<string, decimal>();
var requestUrl = $"{baseUrl}/api/objects?print_stats";
using var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
ApplyApiKey(request, apiKey);
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);
var json = await response.Content.ReadAsStringAsync(cancellationToken);
using var doc = JsonDocument.Parse(json);
// 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 returns: { "result": { "print_stats": { "state": "idle", ... } } }
var state = doc.RootElement
.GetProperty("result")
.GetProperty("print_stats")
.GetProperty("state")
.GetString();
// 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);
return state ?? "unknown";
}
catch (HttpRequestException ex)
{
_logger.LogWarning(ex,
"Failed to retrieve filament usage from Moonraker at {Host}:{Port}",
"Moonraker printer status request failed for {Host}:{Port}",
hostnameOrIp, port);
return "offline";
}
catch (JsonException ex)
{
_logger.LogWarning(ex,
"Malformed Moonraker response from {Host}:{Port}",
hostnameOrIp, port);
return "error";
}
}
/// <inheritdoc />
public async Task<MoonrakerFilamentUsage?> GetFilamentUsageAsync(
string hostnameOrIp,
int port,
string? apiKey = null,
CancellationToken cancellationToken = default)
{
var baseUrl = BuildBaseUrl(hostnameOrIp, port);
// Fetch current print_stats (has live filament_used for active/recent job)
PrintStatsResult? printStats = null;
try
{
printStats = await FetchPrintStatsAsync(baseUrl, apiKey, cancellationToken);
}
catch (HttpRequestException ex)
{
_logger.LogWarning(ex,
"Moonraker print_stats request failed for {Host}:{Port}",
hostnameOrIp, port);
return null;
}
catch (JsonException ex)
{
_logger.LogWarning(ex,
"Malformed Moonraker print_stats response from {Host}:{Port}",
hostnameOrIp, port);
return null;
}
if (printStats is null)
return null;
// Attempt to enrich with history data for timing info
HistoryResult? history = null;
try
{
history = await FetchHistoryAsync(baseUrl, apiKey, cancellationToken);
}
catch (HttpRequestException ex)
{
_logger.LogWarning(ex,
"Moonraker history request failed for {Host}:{Port}",
hostnameOrIp, port);
}
catch (JsonException ex)
{
_logger.LogWarning(ex,
"Failed to parse Moonraker response from {Host}:{Port}",
"Malformed Moonraker history response from {Host}:{Port}",
hostnameOrIp, port);
}
return result;
DateTime? startedAt = null;
DateTime? completedAt = null;
double? printDurationSeconds = null;
if (history is not null)
{
startedAt = history.StartTime;
completedAt = history.EndTime;
printDurationSeconds = history.PrintDuration;
}
return new MoonrakerFilamentUsage
{
MmExtruded = printStats.FilamentUsedMm ?? 0m,
GcodeFileName = printStats.FileName,
PrintState = printStats.State ?? "unknown",
PrintDurationSeconds = printDurationSeconds,
StartedAt = startedAt,
CompletedAt = completedAt
};
}
/// <inheritdoc />
public async Task<bool> IsReachableAsync(
string hostnameOrIp,
int port,
/// <summary>
/// Fetches and parses print_stats from the Moonraker API.
/// </summary>
private async Task<PrintStatsResult?> FetchPrintStatsAsync(
string baseUrl,
string? apiKey,
CancellationToken cancellationToken = default)
CancellationToken cancellationToken)
{
var baseUrl = BuildBaseUrl(hostnameOrIp, port);
var requestUrl = $"{baseUrl}/api/objects?print_stats";
try
using var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
ApplyApiKey(request, apiKey);
using var response = await _httpClient.SendAsync(request, cancellationToken);
response.EnsureSuccessStatusCode();
var json = await response.Content.ReadAsStringAsync(cancellationToken);
using var doc = JsonDocument.Parse(json);
if (!doc.RootElement.TryGetProperty("result", out var result) ||
!result.TryGetProperty("print_stats", out var stats))
{
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;
_logger.LogWarning("Moonraker response missing 'print_stats' object");
return null;
}
catch (HttpRequestException)
return new PrintStatsResult
{
_logger.LogDebug("Moonraker at {Host}:{Port} is not reachable", hostnameOrIp, port);
return false;
State = stats.TryGetProperty("state", out var stateEl) ? stateEl.GetString() : null,
FilamentUsedMm = stats.TryGetProperty("filament_used", out var filamentEl) &&
filamentEl.ValueKind == JsonValueKind.Number
? filamentEl.GetDecimal() : (decimal?)null,
FileName = stats.TryGetProperty("filename", out var fileEl) ? fileEl.GetString() : null
};
}
/// <summary>
/// Fetches and parses history (last job) from the Moonraker API.
/// </summary>
private async Task<HistoryResult?> FetchHistoryAsync(
string baseUrl,
string? apiKey,
CancellationToken cancellationToken)
{
var requestUrl = $"{baseUrl}/api/objects?history";
using var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
ApplyApiKey(request, apiKey);
using var response = await _httpClient.SendAsync(request, cancellationToken);
response.EnsureSuccessStatusCode();
var json = await response.Content.ReadAsStringAsync(cancellationToken);
using var doc = JsonDocument.Parse(json);
if (!doc.RootElement.TryGetProperty("result", out var result) ||
!result.TryGetProperty("history", out var history))
{
_logger.LogWarning("Moonraker response missing 'history' object");
return null;
}
// Try last_job first, then job
JsonElement jobEl;
if (!history.TryGetProperty("last_job", out jobEl) &&
!history.TryGetProperty("job", out jobEl))
{
_logger.LogDebug("Moonraker history has no 'last_job' or 'job' entry");
return null;
}
return new HistoryResult
{
StartTime = ParseDateTimeProperty(jobEl, "start_time"),
EndTime = ParseDateTimeProperty(jobEl, "end_time"),
PrintDuration = jobEl.TryGetProperty("print_duration", out var durEl) &&
durEl.ValueKind == JsonValueKind.Number
? durEl.GetDouble() : (double?)null
};
}
/// <summary>
/// Parses a Moonraker timestamp property (Unix epoch seconds or ISO 8601 string).
/// </summary>
private static DateTime? ParseDateTimeProperty(JsonElement element, string propertyName)
{
if (!element.TryGetProperty(propertyName, out var prop))
return null;
// Moonraker returns Unix epoch seconds as a number
if (prop.ValueKind == JsonValueKind.Number)
{
var epochSeconds = prop.GetDouble();
return DateTime.UnixEpoch.AddSeconds(epochSeconds);
}
// Fallback: try parsing as ISO 8601 string
if (prop.ValueKind == JsonValueKind.String)
{
var str = prop.GetString();
if (str is not null &&
DateTime.TryParse(str, CultureInfo.InvariantCulture,
DateTimeStyles.AssumeUniversal, out var dt))
{
return dt.ToUniversalTime();
}
}
return null;
}
/// <summary>
/// Builds the base URL for Moonraker API calls.
/// </summary>
private static string BuildBaseUrl(string hostnameOrIp, int port) =>
$"http://{hostnameOrIp}:{port}";
/// <summary>
/// Applies the Moonraker API key to the request header if provided.
/// </summary>
private static void ApplyApiKey(HttpRequestMessage request, string? apiKey)
{
if (!string.IsNullOrWhiteSpace(apiKey))
{
request.Headers.Add("X-Api-Key", apiKey);
}
}
/// <summary>
/// Builds the base URL for Moonraker API calls from hostname and port.
/// Parsed result from Moonraker's print_stats object.
/// Extracted immediately from the JSON response to avoid JsonDocument disposal issues.
/// </summary>
private static string BuildBaseUrl(string hostnameOrIp, int port)
private sealed class PrintStatsResult
{
return $"http://{hostnameOrIp}:{port}";
public string? State { get; set; }
public decimal? FilamentUsedMm { get; set; }
public string? FileName { get; set; }
}
/// <summary>
/// Parsed result from Moonraker's history/last_job object.
/// </summary>
private sealed class HistoryResult
{
public DateTime? StartTime { get; set; }
public DateTime? EndTime { get; set; }
public double? PrintDuration { get; set; }
}
}

31
backend/Program.cs
View File

@@ -1,9 +1,8 @@
using System.Reflection;
using System.Net.Http.Headers;
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 +51,22 @@ builder.Services.AddSwaggerGen(c =>
// ── QR Code Generation ──────────────────────────────────────
builder.Services.AddSingleton<IQrCodeService, QrCodeService>();
// ── Cost Per Print Calculation ─────────────────────────────
builder.Services.AddScoped<ICostPerPrintService, CostPerPrintService>();
// ── Filament Usage Service ──────────────────────────────────
builder.Services.AddScoped<IFilamentUsageService, FilamentUsageService>();
// ── Moonraker Client ───────────────────────────────────────
// Named HttpClient for Moonraker API calls with configurable timeout.
// Poller timeout is driven by MoonrakerPollerOptions.RequestTimeout.
builder.Services.AddHttpClient<IMoonrakerClient, MoonrakerClient>(client =>
{
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
});
// ── Moonraker Usage Poller (Background Service) ─────────────
builder.Services.Configure<MoonrakerPollerOptions>(
builder.Configuration.GetSection("MoonrakerPoller"));
builder.Services.AddHostedService<MoonrakerUsagePoller>();
// ── FluentValidation ──────────────────────────────────────
// Registers all validators from the API assembly into DI.
@@ -82,16 +95,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);

5
backend/appsettings.Development.json
View File

@@ -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
}
}

8
backend/appsettings.json
View File

@@ -10,9 +10,9 @@
"ConnectionStrings": {
"ExtrudexDb": "Host=localhost;Port=5432;Database=extrudex;Username=extrudex;Password=changeme"
},
"FilamentUsageSync": {
"PollingInterval": "00:05:00",
"RequestTimeout": "00:00:30",
"Enabled": true
"MoonrakerPoller": {
"Enabled": true,
"PollInterval": "00:00:30",
"RequestTimeout": "00:00:10"
}
}

5
deploy.sh
View File

@@ -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"

40
docker-compose.dev.yml
View File

@@ -1,25 +1,6 @@
services:
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
version: '3.8'
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

16
frontend/package-lock.json generated
View File

@@ -8,6 +8,7 @@
"name": "frontend",
"version": "0.0.0",
"dependencies": {
"@angular/animations": "^21.2.10",
"@angular/cdk": "^21.2.8",
"@angular/common": "^21.2.0",
"@angular/compiler": "^21.2.0",
@@ -326,6 +327,21 @@
"yarn": ">= 1.13.0"
}
},
"node_modules/@angular/animations": {
"version": "21.2.10",
"resolved": "https://registry.npmjs.org/@angular/animations/-/animations-21.2.10.tgz",
"integrity": "sha512-sIzAcxwtRCJ/fu0tK4mo1ooiEaDxJ+Nl6s9nK1D1NP1em12VX03Jx8CMixp/kVtgh4mZnm1x6psBB0FUz3U3Ug==",
"license": "MIT",
"dependencies": {
"tslib": "^2.3.0"
},
"engines": {
"node": "^20.19.0 || ^22.12.0 || >=24.0.0"
},
"peerDependencies": {
"@angular/core": "21.2.10"
}
},
"node_modules/@angular/build": {
"version": "21.2.8",
"resolved": "https://registry.npmjs.org/@angular/build/-/build-21.2.8.tgz",

1
frontend/package.json
View File

@@ -11,6 +11,7 @@
"private": true,
"packageManager": "npm@11.11.0",
"dependencies": {
"@angular/animations": "^21.2.10",
"@angular/cdk": "^21.2.8",
"@angular/common": "^21.2.0",
"@angular/compiler": "^21.2.0",

8
frontend/src/app/app.config.ts
View File

@@ -1,11 +1,15 @@
import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
import { provideRouter } from '@angular/router';
import { provideHttpClient, withFetch } from '@angular/common/http';
import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
import { routes } from './app.routes';
export const appConfig: ApplicationConfig = {
providers: [
provideBrowserGlobalErrorListeners(),
provideRouter(routes)
provideRouter(routes),
provideHttpClient(withFetch()),
provideAnimationsAsync(),
]
};
};

78
frontend/src/app/components/delete-filament-dialog/delete-filament-dialog.component.html Normal file
View File

@@ -0,0 +1,78 @@
<!-- Delete Filament Confirmation Dialog -->
<h2 mat-dialog-title>
<mat-icon aria-hidden="true">warning</mat-icon>
Delete Filament Spool?
</h2>
<mat-dialog-content>
<p class="dialog-description">
You are about to permanently remove this filament spool from inventory.
</p>
<!-- Spool details card -->
<div class="spool-details" role="list" aria-label="Spool details">
<div class="detail-row" role="listitem">
<span class="detail-label">Material</span>
<span class="detail-value">{{ filament.materialBaseName }}{{ filament.materialFinishName ? ' — ' + filament.materialFinishName : '' }}{{ filament.materialModifierName ? ' (' + filament.materialModifierName + ')' : '' }}</span>
</div>
<div class="detail-row" role="listitem">
<span class="detail-label">Brand</span>
<span class="detail-value">{{ filament.brand }}</span>
</div>
<div class="detail-row" role="listitem">
<span class="detail-label">Color</span>
<span class="detail-value color-value">
<span class="color-swatch-inline"
[style.background-color]="filament.colorHex"
[attr.aria-label]="filament.colorName">
</span>
{{ filament.colorName }}
</span>
</div>
<div class="detail-row" role="listitem">
<span class="detail-label">Serial</span>
<span class="detail-value serial-value">{{ filament.spoolSerial }}</span>
</div>
<div class="detail-row" role="listitem">
<span class="detail-label">Remaining</span>
<span class="detail-value">{{ formatWeight(filament.weightRemainingGrams) }} / {{ formatWeight(filament.weightTotalGrams) }}</span>
</div>
<div class="detail-row" role="listitem">
<span class="detail-label">Status</span>
<span class="detail-value">
<span class="status-badge"
[class.active]="filament.isActive"
[class.inactive]="!filament.isActive">
{{ filament.isActive ? 'Active' : 'Inactive' }}
</span>
</span>
</div>
</div>
<p class="dialog-warning">
<mat-icon aria-hidden="true">info</mat-icon>
This action cannot be undone.
</p>
</mat-dialog-content>
<mat-dialog-actions align="end">
<button mat-button
type="button"
(click)="onCancel()"
class="cancel-button">
Cancel
</button>
<button mat-flat-button
type="button"
color="warn"
(click)="onConfirm()"
class="confirm-button">
<mat-icon aria-hidden="true">delete</mat-icon>
Delete Spool
</button>
</mat-dialog-actions>

150
frontend/src/app/components/delete-filament-dialog/delete-filament-dialog.component.scss Normal file
View File

@@ -0,0 +1,150 @@
/**
* Delete Filament Dialog Styles
* Touch-optimized confirmation dialog for spool removal
*/
$spacing-unit: 8px;
$color-critical: #ef4444;
$color-inactive: #94a3b8;
$color-active: #22c55e;
// Dialog title
h2[mat-dialog-title] {
display: flex;
align-items: center;
gap: $spacing-unit;
color: $color-critical;
mat-icon {
font-size: 24px !important;
width: 24px !important;
height: 24px !important;
}
}
// Description text
.dialog-description {
margin: 0 0 $spacing-unit * 2;
font-size: 14px;
line-height: 1.5;
color: var(--mat-sys-on-surface);
}
// Spool details card
.spool-details {
display: flex;
flex-direction: column;
gap: $spacing-unit;
padding: $spacing-unit * 1.5;
background-color: var(--mat-sys-surface-container);
border-radius: 8px;
margin-bottom: $spacing-unit * 2;
}
.detail-row {
display: flex;
justify-content: space-between;
align-items: center;
padding: $spacing-unit * 0.5 0;
font-size: 14px;
&:not(:last-child) {
border-bottom: 1px solid var(--mat-sys-outline-variant);
padding-bottom: $spacing-unit;
}
}
.detail-label {
font-weight: 500;
color: var(--mat-sys-on-surface-variant);
flex-shrink: 0;
}
.detail-value {
font-weight: 400;
color: var(--mat-sys-on-surface);
text-align: right;
}
// Color swatch inline
.color-swatch-inline {
display: inline-block;
width: 18px;
height: 18px;
border-radius: 50%;
border: 1.5px solid rgba(0, 0, 0, 0.12);
vertical-align: middle;
margin-right: 4px;
}
.color-value {
display: flex;
align-items: center;
justify-content: flex-end;
gap: 4px;
}
// Serial value — monospace
.serial-value {
font-family: 'JetBrains Mono', 'Roboto Mono', monospace;
font-size: 13px;
letter-spacing: 0.02em;
}
// Status badge — matches filament table styling
.status-badge {
display: inline-flex;
align-items: center;
padding: 2px 8px;
border-radius: 10px;
font-size: 11px;
font-weight: 600;
text-transform: uppercase;
letter-spacing: 0.04em;
&.active {
background-color: rgba($color-active, 0.12);
color: $color-active;
}
&.inactive {
background-color: rgba($color-inactive, 0.12);
color: $color-inactive;
}
}
// Warning text
.dialog-warning {
display: flex;
align-items: center;
gap: $spacing-unit;
margin: 0;
font-size: 13px;
color: $color-critical;
mat-icon {
font-size: 18px !important;
width: 18px !important;
height: 18px !important;
}
}
// Dialog action buttons
mat-dialog-actions {
padding-top: $spacing-unit * 2;
.cancel-button {
min-width: 80px;
}
.confirm-button {
min-width: 120px;
mat-icon {
font-size: 18px !important;
width: 18px !important;
height: 18px !important;
margin-right: 4px;
}
}
}

68
frontend/src/app/components/delete-filament-dialog/delete-filament-dialog.component.ts Normal file
View File

@@ -0,0 +1,68 @@
import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
import { CommonModule } from '@angular/common';
import {
MAT_DIALOG_DATA,
MatDialogRef,
MatDialogModule,
} from '@angular/material/dialog';
import { MatButtonModule } from '@angular/material/button';
import { MatIconModule } from '@angular/material/icon';
import { MatChipsModule } from '@angular/material/chips';
import { Filament } from '../../models/filament.model';
/**
* Data passed into the delete confirmation dialog.
*/
export interface DeleteFilamentDialogData {
filament: Filament;
}
/**
* Delete confirmation dialog for filament spool removal.
*
* Displays spool details (material, brand, color, serial, remaining weight)
* and requires the user to confirm before deletion proceeds.
* Cancel dismisses the dialog with no action.
*/
@Component({
selector: 'app-delete-filament-dialog',
standalone: true,
imports: [
CommonModule,
MatDialogModule,
MatButtonModule,
MatIconModule,
MatChipsModule,
],
templateUrl: './delete-filament-dialog.component.html',
styleUrl: './delete-filament-dialog.component.scss',
changeDetection: ChangeDetectionStrategy.OnPush,
})
export class DeleteFilamentDialogComponent {
private readonly dialogRef = inject(
MatDialogRef<DeleteFilamentDialogComponent, boolean>
);
readonly data: DeleteFilamentDialogData = inject(MAT_DIALOG_DATA);
/** The filament spool being considered for deletion */
readonly filament = this.data.filament;
/** Format weight for display in dialog */
formatWeight(grams: number): string {
if (grams >= 1000) {
return `${(grams / 1000).toFixed(1)}kg`;
}
return `${Math.round(grams)}g`;
}
/** Cancel — close dialog with false (no deletion) */
onCancel(): void {
this.dialogRef.close(false);
}
/** Confirm — close dialog with true (proceed with deletion) */
onConfirm(): void {
this.dialogRef.close(true);
}
}

76
frontend/src/app/components/filament-filter/filament-filter.component.html
View File

@@ -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>

134
frontend/src/app/components/filament-filter/filament-filter.component.scss
View File

@@ -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;
}
}

158
frontend/src/app/components/filament-filter/filament-filter.component.ts
View File

@@ -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(),
});
}
}

44
frontend/src/app/components/filament-table/filament-table.component.html
View File

@@ -1,12 +1,6 @@
<!-- Filament Inventory Table — with filters and low stock indicators -->
<!-- Filament Inventory Table — with low stock indicators and delete actions -->
<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"
@@ -112,22 +106,36 @@
</td>
</ng-container>
<!-- Actions Column — delete button -->
<ng-container matColumnDef="actions">
<th mat-header-cell *matHeaderCellDef>Actions</th>
<td mat-cell *matCellDef="let filament">
<button mat-icon-button
type="button"
color="warn"
[attr.aria-label]="'Delete ' + filament.materialBaseName + ' — ' + filament.colorName"
matTooltip="Delete spool"
matTooltipPosition="above"
[disabled]="deleting() === filament.id"
(click)="onDeleteClick(filament)">
@if (deleting() === filament.id) {
<mat-icon aria-hidden="true">hourglass_empty</mat-icon>
} @else {
<mat-icon aria-hidden="true">delete</mat-icon>
}
</button>
</td>
</ng-container>
<tr mat-header-row *matHeaderRowDef="columns()"></tr>
<tr mat-row *matRowDef="let row; columns: columns();"
[class.row-critical]="classifyStockLevel(row) === 'critical'"
[class.row-low]="classifyStockLevel(row) === 'low'">
[class.row-low]="classifyStockLevel(row) === 'low'"
[class.row-deleting]="deleting() === row.id">
</tr>
</table>
<!-- Filtered 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 -->
<!-- Empty state -->
@if (filaments().length === 0) {
<div class="empty-state" role="status">
<mat-icon aria-hidden="true">inventory_2</mat-icon>

14
frontend/src/app/components/filament-table/filament-table.component.scss
View File

@@ -235,6 +235,20 @@ mat-chip {
}
}
// Actions column
.actions-cell {
display: flex;
align-items: center;
justify-content: center;
}
// Row being deleted — subtle fade
:host ::ng-deep .row-deleting {
opacity: 0.5;
pointer-events: none;
transition: opacity 0.3s ease;
}
// Empty state
.empty-state {
display: flex;

120
frontend/src/app/components/filament-table/filament-table.component.ts
View File

@@ -3,6 +3,7 @@ import {
Component,
Input,
computed,
inject,
signal,
} from '@angular/core';
import { CommonModule } from '@angular/common';
@@ -12,13 +13,21 @@ 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 { MatButtonModule } from '@angular/material/button';
import { MatDialog, MatDialogModule } from '@angular/material/dialog';
import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
import {
Filament,
StockLevel,
getRemainingPercent,
classifyStockLevel,
} from '../../models/filament.model';
import { FilamentService } from '../../services/filament.service';
import {
DeleteFilamentDialogComponent,
DeleteFilamentDialogData,
} from '../delete-filament-dialog/delete-filament-dialog.component';
/** Display column definitions for the filament table */
export type FilamentColumn =
@@ -28,7 +37,8 @@ export type FilamentColumn =
| 'serial'
| 'remaining'
| 'stockLevel'
| 'status';
| 'status'
| 'actions';
@Component({
selector: 'app-filament-table',
@@ -41,17 +51,26 @@ export type FilamentColumn =
MatProgressBarModule,
MatTooltipModule,
MatSortModule,
FilamentFilterComponent,
MatButtonModule,
MatDialogModule,
MatSnackBarModule,
],
templateUrl: './filament-table.component.html',
styleUrl: './filament-table.component.scss',
changeDetection: ChangeDetectionStrategy.OnPush,
})
export class FilamentTableComponent {
private readonly dialog = inject(MatDialog);
private readonly snackBar = inject(MatSnackBar);
private readonly filamentService = inject(FilamentService);
/** Filament data input — reactive signal for live updates */
readonly filaments = signal<Filament[]>([]);
/** Columns to display — defaults to all columns */
/** Whether a delete operation is in progress */
readonly deleting = signal<string | null>(null);
/** Columns to display — defaults to all columns including actions */
@Input()
set displayedColumns(cols: FilamentColumn[]) {
this._displayedColumns.set(cols);
@@ -67,29 +86,15 @@ export class FilamentTableComponent {
'remaining',
'stockLevel',
'status',
'actions',
]);
/** 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 +233,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,44 +274,50 @@ export class FilamentTableComponent {
this.sortedFilaments.set(sorted);
}
/** Handle filter changes from FilamentFilterComponent */
onFilterChange(state: FilamentFilterState): void {
this.filterState.set(state);
}
/**
* Open the delete confirmation dialog for a filament spool.
* On confirm: calls DELETE endpoint and removes the row on success.
* On cancel: dialog dismissed, no action taken.
*/
onDeleteClick(filament: Filament): void {
const dialogData: DeleteFilamentDialogData = { filament };
const dialogRef = this.dialog.open(DeleteFilamentDialogComponent, {
data: dialogData,
width: '480px',
disableClose: true,
});
/** 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;
dialogRef.afterClosed().subscribe((confirmed: boolean | undefined) => {
if (!confirmed) {
return; // User cancelled — no action
}
}
// Active only filter
if (filters.activeOnly && !filament.isActive) {
return false;
}
// Mark as deleting for UI feedback
this.deleting.set(filament.id);
return true;
this.filamentService.deleteFilament(filament.id).subscribe({
next: () => {
// Remove the deleted filament from local data
const updated = this.filaments().filter((f) => f.id !== filament.id);
this.updateFilaments(updated);
this.deleting.set(null);
this.snackBar.open(
`Deleted ${filament.materialBaseName} — ${filament.colorName}`,
'Dismiss',
{ duration: 4000 }
);
},
error: () => {
this.deleting.set(null);
this.snackBar.open(
`Failed to delete ${filament.materialBaseName} — ${filament.colorName}. Please try again.`,
'Dismiss',
{ duration: 6000 }
);
},
});
});
}
/** Template helper: get remaining percent */

37
frontend/src/app/services/filament.service.ts Normal file
View File

@@ -0,0 +1,37 @@
import { Injectable, inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { Filament } from '../models/filament.model';
/**
* API base URL — matches the Extrudex backend default.
* TODO: Move to environment config when multi-environment support is added.
*/
const API_BASE_URL = '/api';
/**
* Service for CRUD operations on filament spools.
* Communicates with the Extrudex backend SpoolsController.
*/
@Injectable({ providedIn: 'root' })
export class FilamentService {
private readonly http = inject(HttpClient);
/**
* Fetch all filament spools from the backend.
* GET /api/spools
*/
getFilaments(): Observable<Filament[]> {
return this.http.get<Filament[]>(`${API_BASE_URL}/spools`);
}
/**
* Soft-delete a filament spool by ID.
* DELETE /api/spools/{id}
* Returns 204 No Content on success.
*/
deleteFilament(id: string): Observable<void> {
return this.http.delete<void>(`${API_BASE_URL}/spools/${id}`);
}
}