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 1m3s
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

Browse Source
This commit is contained in:
rex-bot
2026-04-27 18:16:45 -04:00
parent 20a22d2dd9
commit 7fe06cf565
35 changed files with 78 additions and 3561 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
};
}

86
backend/API/Controllers/PrintJobsController.cs
View File

@@ -413,92 +413,6 @@ public class PrintJobsController : ControllerBase
return NoContent();
}
// ── GET /api/printjobs/{id}/cost-summary ──────────────────────────
/// <summary>
/// Gets the material cost summary for a specific print job.
/// Calculates total material cost from filament usage (grams derived)
/// and the spool's purchase price. Returns warnings instead of errors
/// when cost data is unavailable.
/// </summary>
/// <param name="id">The unique identifier of the print job.</param>
/// <returns>A cost summary with breakdown and any warnings about missing data.</returns>
/// <response code="200">Returns the cost summary. Warnings field lists any missing data.</response>
/// <response code="404">If the print job with the given ID is not found.</response>
[HttpGet("{id:guid}/cost-summary")]
[ProducesResponseType(typeof(CostSummaryResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult<CostSummaryResponse>> GetCostSummary(Guid id)
{
_logger.LogDebug("Getting cost summary for print job {Id}", id);
var job = await _dbContext.PrintJobs
.Include(j => j.Spool)
.ThenInclude(s => s!.MaterialBase)
.FirstOrDefaultAsync(j => j.Id == id);
if (job is null)
{
_logger.LogWarning("Print job {Id} not found for cost summary", id);
return NotFound(new { error = $"Print job with ID '{id}' not found." });
}
var warnings = new List<string>();
var spool = job.Spool;
// Build response with what we have
var response = new CostSummaryResponse
{
PrintJobId = job.Id,
PrintName = job.PrintName,
SpoolId = job.SpoolId,
SpoolSerial = spool?.SpoolSerial ?? string.Empty,
SpoolBrand = spool?.Brand ?? string.Empty,
SpoolColorName = spool?.ColorName ?? string.Empty,
MmExtruded = job.MmExtruded,
GramsDerived = job.GramsDerived,
SpoolPurchasePrice = spool?.PurchasePrice,
SpoolWeightTotalGrams = spool?.WeightTotalGrams,
StoredCostPerPrint = job.CostPerPrint
};
// Validate spool data availability
if (spool is null)
{
warnings.Add("Spool data is not available for this print job. Cost cannot be calculated.");
response.Warnings = warnings;
return Ok(response);
}
// Check if we can calculate cost
if (!spool.PurchasePrice.HasValue)
{
warnings.Add("Spool purchase price is not set. Cost per gram and total material cost cannot be calculated.");
}
if (spool.WeightTotalGrams <= 0)
{
warnings.Add("Spool total weight is zero or invalid. Cost per gram and total material cost cannot be calculated.");
}
// If we have enough data, calculate the cost
if (spool.PurchasePrice.HasValue && spool.WeightTotalGrams > 0)
{
var pricePerGram = spool.PurchasePrice.Value / spool.WeightTotalGrams;
response.PricePerGram = Math.Round(pricePerGram, 4);
response.TotalMaterialCost = Math.Round(job.GramsDerived * pricePerGram, 4);
}
// Warn if grams derived is zero but mm extruded is non-zero
if (job.GramsDerived == 0 && job.MmExtruded > 0)
{
warnings.Add("GramsDerived is zero despite MmExtruded being non-zero. Cost may be inaccurate. Consider re-deriving grams from filament parameters.");
}
response.Warnings = warnings;
return Ok(response);
}
// ── Gram Derivation Formula ────────────────────────────────────
/// <summary>

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

55
backend/API/DTOs/PrintJobs/CostSummaryResponse.cs
View File

@@ -1,55 +0,0 @@
namespace Extrudex.API.DTOs.PrintJobs;
/// <summary>
/// Response DTO for the cost summary of a print job.
/// Provides a breakdown of material cost based on filament usage
/// and spool pricing data. If cost data is incomplete, warnings
/// are returned instead of throwing an error.
/// </summary>
public class CostSummaryResponse
{
/// <summary>Unique identifier of the print job.</summary>
public Guid PrintJobId { get; set; }
/// <summary>Human-readable name of the print job.</summary>
public string PrintName { get; set; } = string.Empty;
/// <summary>Foreign key to the spool used for this print job.</summary>
public Guid SpoolId { get; set; }
/// <summary>Serial number of the spool.</summary>
public string SpoolSerial { get; set; } = string.Empty;
/// <summary>Brand of the spool.</summary>
public string SpoolBrand { get; set; } = string.Empty;
/// <summary>Color name of the spool.</summary>
public string SpoolColorName { get; set; } = string.Empty;
/// <summary>Total millimeters of filament extruded during this print.</summary>
public decimal MmExtruded { get; set; }
/// <summary>Derived grams consumed for this print job.</summary>
public decimal GramsDerived { get; set; }
/// <summary>Purchase price of the full spool, if available.</summary>
public decimal? SpoolPurchasePrice { get; set; }
/// <summary>Total weight of the spool in grams when full.</summary>
public decimal? SpoolWeightTotalGrams { get; set; }
/// <summary>Calculated price per gram (purchase price / total weight), if available.</summary>
public decimal? PricePerGram { get; set; }
/// <summary>Calculated total material cost for this print job, if available.</summary>
public decimal? TotalMaterialCost { get; set; }
/// <summary>The CostPerPrint stored on the print job entity, if set.</summary>
public decimal? StoredCostPerPrint { get; set; }
/// <summary>
/// Warnings about missing data that prevent cost calculation.
/// Empty if all data is available and cost was calculated successfully.
/// </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");
}
}