diff --git a/Backend/ERPCore/Controllers/ProductionRunsController.cs b/Backend/ERPCore/Controllers/ProductionRunsController.cs new file mode 100644 index 0000000..00d0eb8 --- /dev/null +++ b/Backend/ERPCore/Controllers/ProductionRunsController.cs @@ -0,0 +1,157 @@ +using ERPCore.Domain.Enums; +using ERPCore.Dtos.Common; +using ERPCore.Dtos.Production; +using ERPCore.Services.Interfaces; +using Microsoft.AspNetCore.Mvc; + +namespace ERPCore.Controllers; + +/// Production run endpoints (docs/30-BACKEND-PHASE2.md §D.2–D.3). +[Route("api/v1/production-runs")] +public sealed class ProductionRunsController : ApiControllerBase +{ + private readonly IProductionRunService _runs; + + public ProductionRunsController(IProductionRunService runs) => _runs = runs; + + [HttpGet] + [ProducesResponseType(typeof(PagedResponse), StatusCodes.Status200OK)] + public async Task>> List( + [FromQuery] PageQuery query, + [FromQuery] ProductionRunStatus? status, + [FromQuery] int? templateId, + [FromQuery] int? warehouseId, + CancellationToken ct) + => Ok(await _runs.ListAsync(query, status, templateId, warehouseId, ct)); + + [HttpGet("{runId:int}")] + [ProducesResponseType(typeof(RunGraphDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + public async Task> GetById(int runId, CancellationToken ct) + { + var result = await _runs.GetAsync(runId, ct); + if (result is null) return NotFound(); + + SetETag(result.RowVersion); + return Ok(result.Value); + } + + [HttpPost] + [ProducesResponseType(typeof(RunGraphDto), StatusCodes.Status201Created)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> Create([FromBody] CreateRunRequest request, CancellationToken ct) + { + var result = await _runs.CreateAsync(request, ct); + + SetETag(result.RowVersion); + return Created($"/api/v1/production-runs/{result.Value.RunId}", result.Value); + } + + [HttpPut("{runId:int}/stages/{runStageId:int}/quantities")] + [ProducesResponseType(typeof(RunStageDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> UpdateQuantities( + int runId, int runStageId, [FromBody] UpdateStageQuantitiesRequest request, CancellationToken ct) + => Ok(await _runs.UpdateStageQuantitiesAsync(runId, runStageId, request, ct)); + + // --- stage actions (docs/30 §D.3) --------------------------------------- + // + // Idempotency-Key is accepted on every action to match the Phase-1 contract (docs/11 + // §1.6) but, as in GrnService.ConfirmAsync, it is not stored. Replay safety comes from + // the status guards instead: a double-fire finds the stage already moved on and gets a + // 409, which docs/21 §6 tells the client to treat as a silent refetch. Recorded as a + // deviation from §D.3's "idempotency-key honored". + + [HttpPost("{runId:int}/stages/{runStageId:int}/start")] + [ProducesResponseType(typeof(StartStageResultDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> Start( + int runId, int runStageId, + [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey, + CancellationToken ct) + => Ok(await _runs.StartStageAsync(runId, runStageId, ct)); + + [HttpPost("{runId:int}/stages/{runStageId:int}/complete")] + [ProducesResponseType(typeof(RunStageDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status400BadRequest)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> Complete( + int runId, int runStageId, [FromBody] CompleteStageRequest request, + [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey, + CancellationToken ct) + => Ok(await _runs.CompleteStageAsync(runId, runStageId, request, ct)); + + [HttpPost("{runId:int}/stages/{runStageId:int}/approve")] + [ProducesResponseType(typeof(ApproveStageResultDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> Approve( + int runId, int runStageId, [FromBody] ApproveStageRequest? request, + [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey, + CancellationToken ct) + => Ok(await _runs.ApproveStageAsync(runId, runStageId, request ?? new ApproveStageRequest(), ct)); + + [HttpPost("{runId:int}/stages/{runStageId:int}/transfer")] + [ProducesResponseType(typeof(TransferResultDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> Transfer( + int runId, int runStageId, [FromBody] TransferRemainderRequest request, + [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey, + CancellationToken ct) + => Ok(await _runs.TransferAsync(runId, runStageId, request, ct)); + + [HttpPost("{runId:int}/inputs/{runInputId:int}/return-leftover")] + [ProducesResponseType(typeof(ReturnLeftoverResultDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status400BadRequest)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> ReturnLeftover( + int runId, int runInputId, [FromBody] ReturnLeftoverRequest request, + [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey, + CancellationToken ct) + => Ok(await _runs.ReturnLeftoverAsync(runId, runInputId, request, ct)); + + [HttpPost("{runId:int}/stages/{runStageId:int}/reject-intake")] + [ProducesResponseType(typeof(RejectIntakeResultDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + public async Task> RejectIntake( + int runId, int runStageId, [FromBody] RejectRequest? request, + [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey, + CancellationToken ct) + => Ok(await _runs.RejectIntakeAsync(runId, runStageId, request ?? new RejectRequest(), ct)); + + /// Terminal reject — resets the whole run for a rework pass (FR-MFG-16). + [HttpPost("{runId:int}/stages/{runStageId:int}/reject")] + [ProducesResponseType(typeof(TerminalRejectResultDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + public async Task> Reject( + int runId, int runStageId, [FromBody] RejectRequest? request, + [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey, + CancellationToken ct) + => Ok(await _runs.RejectTerminalAsync(runId, runStageId, request ?? new RejectRequest(), ct)); + + [HttpPost("{runId:int}/cancel")] + [ProducesResponseType(typeof(CancelRunResultDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status400BadRequest)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> Cancel( + int runId, [FromBody] CancelRunRequest request, + [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey, + CancellationToken ct) + => Ok(await _runs.CancelAsync(runId, request, ct)); +} diff --git a/Backend/ERPCore/Controllers/ProductionTemplatesController.cs b/Backend/ERPCore/Controllers/ProductionTemplatesController.cs new file mode 100644 index 0000000..c637741 --- /dev/null +++ b/Backend/ERPCore/Controllers/ProductionTemplatesController.cs @@ -0,0 +1,73 @@ +using ERPCore.Domain.Enums; +using ERPCore.Dtos.Common; +using ERPCore.Dtos.Production; +using ERPCore.Services.Interfaces; +using Microsoft.AspNetCore.Mvc; + +namespace ERPCore.Controllers; + +/// Production template endpoints (docs/30-BACKEND-PHASE2.md §D.1). +[Route("api/v1/production-templates")] +public sealed class ProductionTemplatesController : ApiControllerBase +{ + private readonly IProductionTemplateService _templates; + + public ProductionTemplatesController(IProductionTemplateService templates) => _templates = templates; + + [HttpGet] + [ProducesResponseType(typeof(PagedResponse), StatusCodes.Status200OK)] + public async Task>> List( + [FromQuery] PageQuery query, [FromQuery] EntityStatus? status, CancellationToken ct) + => Ok(await _templates.ListAsync(query, status, ct)); + + [HttpGet("{templateId:int}")] + [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + public async Task> GetById(int templateId, CancellationToken ct) + { + var result = await _templates.GetAsync(templateId, ct); + if (result is null) return NotFound(); + + SetETag(result.RowVersion); + return Ok(result.Value); + } + + [HttpPost] + [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status201Created)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> Create( + [FromBody] SaveTemplateRequest request, CancellationToken ct) + { + var result = await _templates.CreateAsync(request, ct); + + SetETag(result.RowVersion); + return Created($"/api/v1/production-templates/{result.Value.TemplateId}", result.Value); + } + + [HttpPut("{templateId:int}")] + [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + [ProducesResponseType(StatusCodes.Status409Conflict)] + [ProducesResponseType(StatusCodes.Status412PreconditionFailed)] + [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)] + public async Task> Update( + int templateId, [FromBody] SaveTemplateRequest request, CancellationToken ct) + { + var expected = RequireIfMatch(); + var result = await _templates.UpdateAsync(templateId, request, expected, ct); + + SetETag(result.RowVersion); + return Ok(result.Value); + } + + [HttpPatch("{templateId:int}/status")] + [ProducesResponseType(StatusCodes.Status204NoContent)] + [ProducesResponseType(StatusCodes.Status404NotFound)] + public async Task SetStatus( + int templateId, [FromBody] UpdateTemplateStatusRequest request, CancellationToken ct) + { + await _templates.SetStatusAsync(templateId, request.Status, ct); + return NoContent(); + } +} diff --git a/Backend/ERPCore/Domain/DocumentTypes.cs b/Backend/ERPCore/Domain/DocumentTypes.cs index 0a84d94..564e516 100644 --- a/Backend/ERPCore/Domain/DocumentTypes.cs +++ b/Backend/ERPCore/Domain/DocumentTypes.cs @@ -14,4 +14,7 @@ public static class DocumentTypes public const string Adjustment = "ADJ"; public const string Count = "CNT"; public const string PurchaseReturn = "PRET"; + + /// Production run (docs/30 FR-MFG-08) — PRD-2026-00001. + public const string Production = "PRD"; } diff --git a/Backend/ERPCore/Domain/Entities/ProductionRun.cs b/Backend/ERPCore/Domain/Entities/ProductionRun.cs new file mode 100644 index 0000000..4bab646 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/ProductionRun.cs @@ -0,0 +1,59 @@ +using ERPCore.Domain.Enums; + +namespace ERPCore.Domain.Entities; + +/// +/// One execution instance of a template (FR-MFG-08), numbered PRD-2026-00001. +/// Every stage, input, output and edge is copied from the template at creation +/// with quantities scaled by , so a completed run stays +/// readable even if the template is later edited (FR-MFG-06). +/// The run's cost pool is derived, never stored: +/// Σ RunStageInput.ConsumedValue − Σ RunStageInput.ReturnedValue. The terminal +/// approve divides it by the good quantity to cost the finished layer, then closes it +/// (FR-MFG-13, 409 RUN_COST_CLOSED). +/// Mutable aggregate with a token. Model: docs/30 Part C. +/// +public class ProductionRun +{ + public int RunId { get; set; } + public string DocNo { get; set; } = string.Empty; + + public int TemplateId { get; set; } + public ProductionTemplate? Template { get; set; } + + /// Stock inputs are consumed from, and the finished good received into, this warehouse. + public int WarehouseId { get; set; } + public Warehouse? Warehouse { get; set; } + + /// Optional destination bin for the finished goods. Reaches the ledger only — stock layers carry no bin. + public int? OutputBinId { get; set; } + public Bin? OutputBin { get; set; } + + /// Target quantity of the finished item; drives . + public decimal TargetQty { get; set; } + + /// TargetQty / terminalOutput.QtyPerBatch, applied to every copied quantity. + public decimal ScaleFactor { get; set; } + + public ProductionRunStatus Status { get; set; } = ProductionRunStatus.InProgress; + + /// Incremented by each terminal reject (FR-MFG-16); prior figures live in the event history. + public int ReworkCount { get; set; } + + public int? CancelReasonCodeId { get; set; } + public ReasonCode? CancelReason { get; set; } + + public int CreatedBy { get; set; } + public User? Creator { get; set; } + + public DateTime CreatedAt { get; set; } + + /// Set by the terminal approve only. A cancelled run leaves this null. + public DateTime? CompletedAt { get; set; } + + public uint RowVersion { get; set; } + + public ICollection Stages { get; set; } = new List(); + public ICollection Edges { get; set; } = new List(); + public ICollection Events { get; set; } = new List(); +} diff --git a/Backend/ERPCore/Domain/Entities/ProductionTemplate.cs b/Backend/ERPCore/Domain/Entities/ProductionTemplate.cs new file mode 100644 index 0000000..2a79aea --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/ProductionTemplate.cs @@ -0,0 +1,43 @@ +using ERPCore.Domain.Enums; + +namespace ERPCore.Domain.Entities; + +/// +/// A reusable production-line definition — the stage graph designed on the canvas +/// (FR-MFG-01). Never hard-deleted once referenced by a run; deactivated instead +/// (FR-MD-08 posture). Editing is locked while any run of it is InProgress +/// (FR-MFG-06, 409 TEMPLATE_IN_USE) — edit-lock replaces versioning, which is +/// why runs copy display fields at creation. Mutable aggregate with a +/// token. Model: docs/30 Part C. +/// +public class ProductionTemplate +{ + public int TemplateId { get; set; } + public string Code { get; set; } = string.Empty; + public string Name { get; set; } = string.Empty; + public string? Description { get; set; } + + public EntityStatus Status { get; set; } = EntityStatus.Active; + + /// + /// Canvas-only annotations (grouping boxes and divider lines) as a jsonb array, stored + /// verbatim and never interpreted server-side. + /// + /// + /// Not in docs/30 Part C — added because the builder canvas already draws these and + /// without somewhere to keep them a save would silently discard the user's layout notes. + /// They carry no graph semantics: no ports, no edges, and the validator never sees them. + /// Nullable so a template that has none stores nothing rather than an empty array. + /// + public string? Annotations { get; set; } + + public int CreatedBy { get; set; } + public User? Creator { get; set; } + + public DateTime CreatedAt { get; set; } + public uint RowVersion { get; set; } + + public ICollection Stages { get; set; } = new List(); + public ICollection Edges { get; set; } = new List(); + public ICollection Runs { get; set; } = new List(); +} diff --git a/Backend/ERPCore/Domain/Entities/RunEdge.cs b/Backend/ERPCore/Domain/Entities/RunEdge.cs new file mode 100644 index 0000000..ba70037 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/RunEdge.cs @@ -0,0 +1,28 @@ +namespace ERPCore.Domain.Entities; + +/// +/// A parent → child arrow copied from the template's set at run +/// creation. +/// Addition to docs/30 Part C (recorded). The doc's entity model has no run +/// edge table, but the run graph needs its own copy: deriving edges at read time through +/// RunStage.TemplateStageId → STAGE_EDGE would let a later template edit silently +/// rewrite completed-run history — the exact thing FR-MFG-06 exists to prevent — and +/// breaks outright once that link is nulled by a stage deletion. +/// Used for the run canvas, child-readiness evaluation and reject-intake's +/// "delivering parents". Note that WIP delivery is routed by +/// RunStageInput.FromRunOutputId, not by these edges — an edge is display and +/// validation only. +/// +public class RunEdge +{ + public int RunEdgeId { get; set; } + + public int RunId { get; set; } + public ProductionRun? Run { get; set; } + + public int ParentRunStageId { get; set; } + public RunStage? ParentRunStage { get; set; } + + public int ChildRunStageId { get; set; } + public RunStage? ChildRunStage { get; set; } +} diff --git a/Backend/ERPCore/Domain/Entities/RunStage.cs b/Backend/ERPCore/Domain/Entities/RunStage.cs new file mode 100644 index 0000000..9d223b6 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/RunStage.cs @@ -0,0 +1,59 @@ +using ERPCore.Domain.Enums; + +namespace ERPCore.Domain.Entities; + +/// +/// One stage of a run — a copy of a taken at run creation +/// (FR-MFG-06), carrying its own live status and actual timings. Model: docs/30 Part C. +/// Whether this stage is terminal is derived, never stored: a stage is +/// terminal when it has no outbound . Storing it would let it +/// drift from the edge set. +/// +public class RunStage +{ + public int RunStageId { get; set; } + + public int RunId { get; set; } + public ProductionRun? Run { get; set; } + + /// + /// Provenance link back to the template stage. Nullable: a template PUT may + /// delete a stage while completed/cancelled runs still reference it (the edit-lock + /// only blocks edits during InProgress runs), so the FK is SET NULL rather + /// than blocking the edit forever. Everything needed to display a historical run is + /// copied below, which is exactly what FR-MFG-06 anticipates. + /// + public int? TemplateStageId { get; set; } + public TemplateStage? TemplateStage { get; set; } + + // --- copied from the template at run creation (FR-MFG-06) --- + public string Name { get; set; } = string.Empty; + public string? RoleLabel { get; set; } + public int EstimatedMinutes { get; set; } + public decimal PosX { get; set; } + public decimal PosY { get; set; } + + public ProductionStageStatus Status { get; set; } = ProductionStageStatus.Waiting; + + /// Stamped at start; preserved across a reject-intake rework so the original start stands (FR-MFG-19). + public DateTime? ActualStartAt { get; set; } + public DateTime? ActualEndAt { get; set; } + + /// Copied from the template stage; definitions survive a rework. + public string FieldDefs { get; set; } = "[]"; + + /// Captured at complete as a jsonb object; cleared by a terminal reject so required fields are re-answered. + public string? FieldValues { get; set; } + + /// + /// Concurrency token. Stage actions re-read the stage inside their transaction and + /// let this xmin check serialize concurrent requests — it is what stops two + /// simultaneous terminal approves from both reading Done and posting two + /// receipts. See the idempotency note in ProductionRunService. + /// + public uint RowVersion { get; set; } + + public ICollection Inputs { get; set; } = new List(); + public ICollection Outputs { get; set; } = new List(); + public ICollection Events { get; set; } = new List(); +} diff --git a/Backend/ERPCore/Domain/Entities/RunStageEvent.cs b/Backend/ERPCore/Domain/Entities/RunStageEvent.cs new file mode 100644 index 0000000..631dbcc --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/RunStageEvent.cs @@ -0,0 +1,40 @@ +using ERPCore.Domain.Enums; + +namespace ERPCore.Domain.Entities; + +/// +/// Immutable history of everything that happened to a run (docs/30 Part C). Written by +/// every mutating action and never updated or deleted, so a run's story — including the +/// figures discarded by each rework — survives in full. +/// Addition to docs/30 Part C (recorded): . The doc hangs +/// events off the stage only, which leaves run-level events (cancel, terminal reject) +/// with no home and forces the detail timeline to join through stages. Keeping both +/// links makes optional and the timeline a single query. +/// +public class RunStageEvent +{ + public int EventId { get; set; } + + public int RunId { get; set; } + public ProductionRun? Run { get; set; } + + /// Null for run-level events (Cancel). + public int? RunStageId { get; set; } + public RunStage? RunStage { get; set; } + + public RunStageEventType EventType { get; set; } + + public string? Note { get; set; } + + /// + /// Event-specific detail as jsonb — consumed layers on a Start, pulled-back + /// quantities on a RejectIntake, the full pre-rework snapshot on a TerminalReject. + /// Pre-serialized string, written only through ProductionJson. + /// + public string? Payload { get; set; } + + public int UserId { get; set; } + public User? User { get; set; } + + public DateTime CreatedAt { get; set; } +} diff --git a/Backend/ERPCore/Domain/Entities/RunStageInput.cs b/Backend/ERPCore/Domain/Entities/RunStageInput.cs new file mode 100644 index 0000000..a1b9c09 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/RunStageInput.cs @@ -0,0 +1,55 @@ +using ERPCore.Domain.Enums; + +namespace ERPCore.Domain.Entities; + +/// +/// One input line of a run stage — a copy of a with its +/// quantity scaled at creation, plus the live consumption/delivery figures. +/// Model: docs/30 Part C. +/// Stock inputs accumulate / +/// at each start and / on leftover +/// return or run cancel. Those four columns are the whole cost pool +/// (Σ consumed − Σ returned) and are deliberately not reset by a terminal +/// reject — already-consumed material stays in the pool (FR-MFG-16). +/// Upstream inputs accumulate as parent stages +/// transfer WIP in. The stage becomes Ready only when every upstream input has +/// DeliveredQty >= PlannedQty (FR-MFG-09, an all-parents join). +/// +public class RunStageInput +{ + public int RunInputId { get; set; } + + public int RunStageId { get; set; } + public RunStage? RunStage { get; set; } + + public StageInputSource Source { get; set; } + + public int? ItemId { get; set; } + public Item? Item { get; set; } + + /// The parent output feeding this input. This — not — is what routes a transfer. + public int? FromRunOutputId { get; set; } + public RunStageOutput? FromRunOutput { get; set; } + + public int UomId { get; set; } + public Uom? Uom { get; set; } + + /// Scaled at creation; per-run editable until the stage starts (FR-MFG-08, 409 STAGE_NOT_EDITABLE). + public decimal PlannedQty { get; set; } + + /// + /// Stock inputs only, in the item's base UOM. A start consumes + /// max(0, PlannedQty − ConsumedQty) and adds to these, so a rework restart + /// with an unchanged planned quantity consumes nothing and one with a raised planned + /// quantity consumes only the delta (FR-MFG-16). + /// + public decimal ConsumedQty { get; set; } + public decimal ConsumedValue { get; set; } + + /// Upstream inputs only: accumulated by parent transfers. + public decimal DeliveredQty { get; set; } + + /// Leftover returns (FR-MFG-14) and cancel returns (FR-MFG-17), at the consumed weighted cost. + public decimal ReturnedQty { get; set; } + public decimal ReturnedValue { get; set; } +} diff --git a/Backend/ERPCore/Domain/Entities/RunStageOutput.cs b/Backend/ERPCore/Domain/Entities/RunStageOutput.cs new file mode 100644 index 0000000..6b7d801 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/RunStageOutput.cs @@ -0,0 +1,43 @@ +namespace ERPCore.Domain.Entities; + +/// +/// One output line of a run stage — a copy of a with its +/// quantity scaled at creation, plus the live produced/scrapped/transferred figures. +/// Model: docs/30 Part C. +/// Available to transfer is derived, never stored: +/// ProducedQty − ScrappedQty − TransferredQty. Every transfer path checks it and +/// raises 422 TRANSFER_EXCEEDS_AVAILABLE (FR-MFG-12). +/// Scrap cost is absorbed into the run cost pool as normal yield loss — no +/// write-off ledger entry is posted (FR-MFG-11). +/// +public class RunStageOutput +{ + public int RunOutputId { get; set; } + + public int RunStageId { get; set; } + public RunStage? RunStage { get; set; } + + /// Null on intermediate (WIP) outputs; set on the terminal output — the finished good. + public int? ItemId { get; set; } + public Item? Item { get; set; } + + public string Name { get; set; } = string.Empty; + + public int UomId { get; set; } + public Uom? Uom { get; set; } + + /// Scaled at creation; per-run editable until the stage starts. + public decimal PlannedQty { get; set; } + + /// Recorded at complete. A re-complete after a rework overwrites this, never adds to it. + public decimal ProducedQty { get; set; } + + public decimal ScrappedQty { get; set; } + + /// Mandatory when > 0, context Production (FR-MFG-11). + public int? ScrapReasonCodeId { get; set; } + public ReasonCode? ScrapReason { get; set; } + + /// Total WIP handed to children so far, across approve and any later partial transfers. + public decimal TransferredQty { get; set; } +} diff --git a/Backend/ERPCore/Domain/Entities/StageEdge.cs b/Backend/ERPCore/Domain/Entities/StageEdge.cs new file mode 100644 index 0000000..c402369 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/StageEdge.cs @@ -0,0 +1,21 @@ +namespace ERPCore.Domain.Entities; + +/// +/// A parent → child arrow on the template canvas. The edge set must form a DAG with +/// at least one entry stage and exactly one terminal stage; that is enforced in +/// ProductionGraphValidator on every save, not by the database (FR-MFG-02). +/// Model: docs/30 Part C. +/// +public class StageEdge +{ + public int EdgeId { get; set; } + + public int TemplateId { get; set; } + public ProductionTemplate? Template { get; set; } + + public int ParentStageId { get; set; } + public TemplateStage? ParentStage { get; set; } + + public int ChildStageId { get; set; } + public TemplateStage? ChildStage { get; set; } +} diff --git a/Backend/ERPCore/Domain/Entities/StageInput.cs b/Backend/ERPCore/Domain/Entities/StageInput.cs new file mode 100644 index 0000000..dd63212 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/StageInput.cs @@ -0,0 +1,39 @@ +using ERPCore.Domain.Enums; + +namespace ERPCore.Domain.Entities; + +/// +/// One line of a stage's input formula (FR-MFG-04). Exactly one of the two source +/// shapes applies, enforced by ProductionGraphValidator: +/// +/// — set, +/// null. FIFO-consumed from the run warehouse at stage +/// start. Allowed on any stage, e.g. packaging added late. +/// — set to +/// an output of a direct parent stage, null. Flows as +/// internal WIP and never touches stock or the ledger. +/// +/// Model: docs/30 Part C. +/// +public class StageInput +{ + public int InputId { get; set; } + + public int StageId { get; set; } + public TemplateStage? Stage { get; set; } + + public StageInputSource Source { get; set; } + + /// Required when is Stock; null when Upstream. + public int? ItemId { get; set; } + public Item? Item { get; set; } + + /// Required when is Upstream; must belong to a direct parent. + public int? FromOutputId { get; set; } + public StageOutput? FromOutput { get; set; } + + public int UomId { get; set; } + public Uom? Uom { get; set; } + + public decimal QtyPerBatch { get; set; } +} diff --git a/Backend/ERPCore/Domain/Entities/StageOutput.cs b/Backend/ERPCore/Domain/Entities/StageOutput.cs new file mode 100644 index 0000000..2bd69e6 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/StageOutput.cs @@ -0,0 +1,27 @@ +namespace ERPCore.Domain.Entities; + +/// +/// A named quantity produced by a stage (FR-MFG-05). Intermediate outputs are +/// internal WIP only — is null, no stock and no ledger row +/// is ever written for them. The terminal stage is the exception: it has exactly one +/// output and that output must reference a real Item (the finished good), which +/// is what the production receipt creates a layer for. Model: docs/30 Part C. +/// +public class StageOutput +{ + public int OutputId { get; set; } + + public int StageId { get; set; } + public TemplateStage? Stage { get; set; } + + /// Null on intermediate stages; required on the terminal stage. + public int? ItemId { get; set; } + public Item? Item { get; set; } + + public string Name { get; set; } = string.Empty; + + public int UomId { get; set; } + public Uom? Uom { get; set; } + + public decimal QtyPerBatch { get; set; } +} diff --git a/Backend/ERPCore/Domain/Entities/TemplateStage.cs b/Backend/ERPCore/Domain/Entities/TemplateStage.cs new file mode 100644 index 0000000..4223c18 --- /dev/null +++ b/Backend/ERPCore/Domain/Entities/TemplateStage.cs @@ -0,0 +1,36 @@ +namespace ERPCore.Domain.Entities; + +/// +/// One box on the template canvas (FR-MFG-03): a named step with a role label, an +/// estimated duration, a formula ( + ) and +/// custom field definitions. Model: docs/30 Part C. +/// +public class TemplateStage +{ + public int StageId { get; set; } + + public int TemplateId { get; set; } + public ProductionTemplate? Template { get; set; } + + public string Name { get; set; } = string.Empty; + + /// Free text (e.g. "QA"). Informational only this phase — never enforced (FR-X-01). + public string? RoleLabel { get; set; } + + public int EstimatedMinutes { get; set; } + + /// Canvas coordinates — stored verbatim, never interpreted server-side (FR-MFG-03). + public decimal PosX { get; set; } + public decimal PosY { get; set; } + + /// + /// Custom field definitions as jsonb: [{ key, label, type, options?, required }] + /// (FR-MFG-07). Held as a pre-serialized string, matching the AuditLog.ChangeSet + /// precedent; always written through ProductionJson so the column can only ever + /// hold canonical JSON. + /// + public string FieldDefs { get; set; } = "[]"; + + public ICollection Inputs { get; set; } = new List(); + public ICollection Outputs { get; set; } = new List(); +} diff --git a/Backend/ERPCore/Domain/Enums/CustomFieldType.cs b/Backend/ERPCore/Domain/Enums/CustomFieldType.cs new file mode 100644 index 0000000..6419636 --- /dev/null +++ b/Backend/ERPCore/Domain/Enums/CustomFieldType.cs @@ -0,0 +1,16 @@ +namespace ERPCore.Domain.Enums; + +/// +/// Input type of a stage custom field (FR-MFG-07; docs/30 §D.5 fieldType). +/// Lives inside the field_defs jsonb rather than a column, but is modelled as an +/// enum so a bad value is rejected at the DTO boundary instead of reaching the database. +/// is the only type that reads options. +/// +public enum CustomFieldType +{ + Text, + Number, + Checkbox, + Date, + Select +} diff --git a/Backend/ERPCore/Domain/Enums/ProductionRunStatus.cs b/Backend/ERPCore/Domain/Enums/ProductionRunStatus.cs new file mode 100644 index 0000000..7d9a024 --- /dev/null +++ b/Backend/ERPCore/Domain/Enums/ProductionRunStatus.cs @@ -0,0 +1,14 @@ +namespace ERPCore.Domain.Enums; + +/// +/// Lifecycle of a production run (docs/30 §B.4, §D.5). A run is created +/// and reaches exactly one final state: it completes at the +/// terminal stage's approve (production receipt, FR-MFG-13) or is cancelled with a +/// stock return (FR-MFG-17). Stored as a string. +/// +public enum ProductionRunStatus +{ + InProgress, + Completed, + Cancelled +} diff --git a/Backend/ERPCore/Domain/Enums/ProductionStageStatus.cs b/Backend/ERPCore/Domain/Enums/ProductionStageStatus.cs new file mode 100644 index 0000000..f5e04a0 --- /dev/null +++ b/Backend/ERPCore/Domain/Enums/ProductionStageStatus.cs @@ -0,0 +1,22 @@ +namespace ERPCore.Domain.Enums; + +/// +/// Status of one stage within a production run (docs/30 §B.4, §D.5). +/// +/// Waiting ──(all upstream inputs fully delivered)──▶ Ready +/// Ready ──start (FIFO-consume Stock inputs)──▶ InProgress +/// InProgress ──complete (produced/scrap/fields)──▶ Done +/// Done ──approve──▶ Approved (non-terminal: WIP transfers out; terminal: receipt) +/// +/// Rejection is not a resting state (FR-MFG-15/16): a reject immediately produces a +/// rework transition back into this set and is recorded as a +/// instead. Stored as a string. +/// +public enum ProductionStageStatus +{ + Waiting, + Ready, + InProgress, + Done, + Approved +} diff --git a/Backend/ERPCore/Domain/Enums/ReasonContext.cs b/Backend/ERPCore/Domain/Enums/ReasonContext.cs index b569040..10a8b18 100644 --- a/Backend/ERPCore/Domain/Enums/ReasonContext.cs +++ b/Backend/ERPCore/Domain/Enums/ReasonContext.cs @@ -5,5 +5,8 @@ public enum ReasonContext { Adjustment, Return, - Count + Count, + + /// Manufacturing: scrap, leftover return, run cancel (docs/30 §A.2). + Production } diff --git a/Backend/ERPCore/Domain/Enums/RunStageEventType.cs b/Backend/ERPCore/Domain/Enums/RunStageEventType.cs new file mode 100644 index 0000000..0e1e173 --- /dev/null +++ b/Backend/ERPCore/Domain/Enums/RunStageEventType.cs @@ -0,0 +1,20 @@ +namespace ERPCore.Domain.Enums; + +/// +/// Kind of entry in a run's immutable history (docs/30 Part C, RUN_STAGE_EVENT). +/// Every mutating action on a run writes exactly one event carrying who/when plus a +/// jsonb payload; additionally snapshots the whole run's +/// figures for the rework pass being discarded (FR-MFG-16). Stored as a string. +/// +public enum RunStageEventType +{ + Start, + Complete, + Approve, + Transfer, + RejectIntake, + TerminalReject, + LeftoverReturn, + Cancel, + QuantityEdit +} diff --git a/Backend/ERPCore/Domain/Enums/StageInputSource.cs b/Backend/ERPCore/Domain/Enums/StageInputSource.cs new file mode 100644 index 0000000..2635415 --- /dev/null +++ b/Backend/ERPCore/Domain/Enums/StageInputSource.cs @@ -0,0 +1,14 @@ +namespace ERPCore.Domain.Enums; + +/// +/// Where a stage input's material comes from (FR-MFG-04; docs/30 §D.5). +/// inputs reference an Item and are FIFO-consumed from the run +/// warehouse when the stage starts. inputs reference a direct +/// parent stage's output and flow as internal WIP — they never touch the ledger. +/// Stored as a string. +/// +public enum StageInputSource +{ + Stock, + Upstream +} diff --git a/Backend/ERPCore/Domain/LedgerSourceTypes.cs b/Backend/ERPCore/Domain/LedgerSourceTypes.cs new file mode 100644 index 0000000..e6cab32 --- /dev/null +++ b/Backend/ERPCore/Domain/LedgerSourceTypes.cs @@ -0,0 +1,34 @@ +namespace ERPCore.Domain; + +/// +/// Additional STOCK_LEDGER.source_doc_type values for manufacturing movements +/// (docs/30 §A.2). source_doc_id is always the run_id, so +/// LIKE 'PRD%' traces every stock movement a run caused. +/// +/// +/// Deviation from docs/30 §A.2 (recorded). The doc proposes the long names +/// ProductionIssue/ProductionReceipt/ProductionReturn/ +/// ProductionCancelReturn, but both stock_ledger.SourceDocType and +/// journal_entry_stubs.SourceDocType are varchar(10) and every existing +/// value is a short prefix (GRN, TRF, ADJ, PRET). Widening +/// those columns would be a second Phase-1 schema change beyond the single deviation +/// §A.1 declares (NFR-08), so the short codes below extend the existing convention +/// instead. docs/30 §A.2 and §D.5 are amended to match. +/// These are not entries — production issues no +/// document per movement. The run's own document number uses +/// (PRD-2026-00001). +/// +public static class LedgerSourceTypes +{ + /// Stock consumed by a stage start (FR-MFG-10). Outbound. + public const string ProductionIssue = "PRDI"; + + /// Finished goods received at the terminal approve (FR-MFG-13). Inbound. + public const string ProductionReceipt = "PRDR"; + + /// Unconsumed material returned before receipt (FR-MFG-14). Inbound. + public const string ProductionReturn = "PRDL"; + + /// Net consumed stock returned when a run is cancelled (FR-MFG-17). Inbound. + public const string ProductionCancelReturn = "PRDC"; +} diff --git a/Backend/ERPCore/Dtos/Production/RunDtos.cs b/Backend/ERPCore/Dtos/Production/RunDtos.cs new file mode 100644 index 0000000..50de0a8 --- /dev/null +++ b/Backend/ERPCore/Dtos/Production/RunDtos.cs @@ -0,0 +1,113 @@ +using System.ComponentModel.DataAnnotations; +using System.Text.Json; +using ERPCore.Domain.Enums; + +namespace ERPCore.Dtos.Production; + +// Production run contract (docs/30-BACKEND-PHASE2.md §D.2–D.3). +// +// Statuses are never client-settable (02-SECURITY §B.6): a run's status and every stage +// status move only through the stage-action endpoints. Requests here carry quantities and +// references, nothing else. + +// --- responses --------------------------------------------------------------- + +/// Per-status stage counts driving the board's progress strip (FR-MFG-18, docs/21 §3). +public sealed record StageSummaryDto(int Waiting, int Ready, int InProgress, int Done, int Approved); + +/// Row on the run board (docs/30 §D.2 GET /production-runs). +public sealed record RunSummaryDto( + int RunId, string DocNo, int TemplateId, string TemplateName, + decimal TargetQty, ProductionRunStatus Status, int ReworkCount, + StageSummaryDto StageSummary, int WarehouseId, + int? FinishedItemId, string? FinishedItemName, + int CreatedBy, DateTime CreatedAt, DateTime? CompletedAt); + +/// +/// The run cost pool (FR-MFG-13). Always derived from the stage inputs, never stored — +/// surfaced so the UI can preview the finished unit cost before approving the terminal. +/// +public sealed record CostPoolDto(decimal Consumed, decimal Returned, decimal Net); + +public sealed record RunStageInputDto( + int RunInputId, StageInputSource Source, int? ItemId, int? FromRunOutputId, int UomId, + decimal PlannedQty, decimal ConsumedQty, decimal ConsumedValue, + decimal DeliveredQty, decimal ReturnedQty, decimal ReturnedValue); + +/// +/// One output of a run stage. AvailableToTransfer is derived — produced − scrapped − +/// transferred (FR-MFG-12) — and never stored. +/// +public sealed record RunStageOutputDto( + int RunOutputId, int? ItemId, string Name, int UomId, + decimal PlannedQty, decimal ProducedQty, decimal ScrappedQty, int? ScrapReasonCodeId, + decimal TransferredQty, decimal AvailableToTransfer); + +/// +/// One stage of a run. IsTerminal (no outbound edge) and IsEntry (no inbound +/// edge) are derived from the run edge set rather than stored, so they cannot drift from it. +/// ActualMinutes is the elapsed whole minutes once the stage has finished, null while +/// it is still running (FR-MFG-19). FieldValues is the raw jsonb captured at complete, +/// passed through verbatim. +/// +public sealed record RunStageDto( + int RunStageId, int? TemplateStageId, string Name, string? RoleLabel, + int EstimatedMinutes, decimal PosX, decimal PosY, + ProductionStageStatus Status, bool IsTerminal, bool IsEntry, + DateTime? ActualStartAt, DateTime? ActualEndAt, int? ActualMinutes, + IReadOnlyList FieldDefs, JsonElement? FieldValues, + IReadOnlyList Inputs, IReadOnlyList Outputs); + +public sealed record RunEdgeDto(int RunEdgeId, int ParentRunStageId, int ChildRunStageId); + +public sealed record RunEventDto( + int EventId, int? RunStageId, RunStageEventType EventType, string? Note, + JsonElement? Payload, int UserId, DateTime CreatedAt); + +/// Full run graph (docs/30 §D.2 GET /production-runs/{id}). +public sealed record RunGraphDto( + int RunId, string DocNo, int TemplateId, string TemplateName, + int WarehouseId, int? OutputBinId, + decimal TargetQty, decimal ScaleFactor, + ProductionRunStatus Status, int ReworkCount, int? CancelReasonCodeId, + CostPoolDto CostPool, + IReadOnlyList Stages, IReadOnlyList Edges, IReadOnlyList Events, + int CreatedBy, DateTime CreatedAt, DateTime? CompletedAt); + +// --- requests ---------------------------------------------------------------- + +public sealed class CreateRunRequest +{ + [Range(1, int.MaxValue)] + public int TemplateId { get; set; } + + /// Quantity of the finished item; drives the whole graph's scale factor (FR-MFG-08). + [Range(0.0001, double.MaxValue)] + public decimal TargetQty { get; set; } + + [Range(1, int.MaxValue)] + public int WarehouseId { get; set; } + + /// Optional bin for the finished goods; must belong to . + public int? OutputBinId { get; set; } +} + +/// +/// Per-run scaling override (FR-MFG-08). Only accepted while the stage has not started +/// (409 STAGE_NOT_EDITABLE). +/// +public sealed class UpdateStageQuantitiesRequest +{ + public List Inputs { get; set; } = new(); + public List Outputs { get; set; } = new(); +} + +public sealed class StageQuantityLine +{ + /// The runInputId or runOutputId being adjusted. + [Range(1, int.MaxValue)] + public int Id { get; set; } + + [Range(0.0001, double.MaxValue)] + public decimal PlannedQty { get; set; } +} diff --git a/Backend/ERPCore/Dtos/Production/StageActionDtos.cs b/Backend/ERPCore/Dtos/Production/StageActionDtos.cs new file mode 100644 index 0000000..c4ad03b --- /dev/null +++ b/Backend/ERPCore/Dtos/Production/StageActionDtos.cs @@ -0,0 +1,177 @@ +using System.ComponentModel.DataAnnotations; +using System.Text.Json; +using ERPCore.Domain.Enums; + +namespace ERPCore.Dtos.Production; + +// Stage-action contract (docs/30-BACKEND-PHASE2.md §D.3). Every action is transactional, +// guards on the stage's current status, and returns the refreshed stage plus whatever +// stock effects it caused. + +// --- start ------------------------------------------------------------------- + +/// One FIFO layer a stage start drew from, at that layer's cost. +public sealed record ConsumedLayerDto(int LayerId, decimal Qty, decimal UnitCost); + +/// What a single Stock input consumed at start (FR-MFG-10). +public sealed record ConsumedInputDto( + int RunInputId, int ItemId, decimal Qty, decimal Value, IReadOnlyList ConsumedLayers); + +public sealed record StartStageResultDto( + int RunStageId, ProductionStageStatus Status, DateTime? ActualStartAt, + IReadOnlyList Consumed, IReadOnlyList LedgerRefs, + RunStageDto Stage); + +// --- complete ---------------------------------------------------------------- + +public sealed class CompleteStageRequest +{ + [Required, MinLength(1)] + public List Outputs { get; set; } = new(); + + /// + /// Values for the stage's custom fields, keyed by fieldDefs[].key. Every field + /// marked required must be present and non-empty (400 REQUIRED_FIELD_MISSING). + /// + public JsonElement? FieldValues { get; set; } +} + +public sealed class CompleteOutputLine +{ + [Range(1, int.MaxValue)] + public int RunOutputId { get; set; } + + [Range(0, double.MaxValue)] + public decimal ProducedQty { get; set; } + + [Range(0, double.MaxValue)] + public decimal ScrappedQty { get; set; } + + /// Mandatory once > 0; must be a Production reason. + public int? ScrapReasonCodeId { get; set; } +} + +// --- approve / transfer ------------------------------------------------------ + +/// +/// One WIP hand-off from a parent output to a child input. Deliveries route by +/// fromRunOutputId, not by edge — see the note on RunEdge. +/// +public sealed record TransferDto( + int RunOutputId, int RunInputId, int ChildRunStageId, decimal Qty, + decimal ChildDeliveredQty, ProductionStageStatus ChildStatus); + +/// The finished-goods layer a terminal approve created (FR-MFG-13). +public sealed record ReceiptDto( + int LayerId, int ItemId, int WarehouseId, int? BinId, + decimal QtyReceived, decimal UnitCost, decimal Value); + +public sealed record ApproveStageResultDto( + int RunStageId, ProductionStageStatus Status, ProductionRunStatus RunStatus, + IReadOnlyList Transfers, + ReceiptDto? Receipt, CostPoolDto? CostPool, IReadOnlyList LedgerRefs, + RunStageDto Stage); + +public sealed class ApproveStageRequest +{ + /// + /// Optional partial transfers. Omitted or empty means transfer the full available + /// quantity of every output (FR-MFG-12). + /// + public List Transfers { get; set; } = new(); +} + +public sealed class TransferLine +{ + [Range(1, int.MaxValue)] + public int RunOutputId { get; set; } + + [Range(0.0001, double.MaxValue)] + public decimal Qty { get; set; } + + /// + /// Optional explicit target. When an output feeds several child inputs the server + /// otherwise fills them in runInputId order; naming one removes the ambiguity. + /// + public int? RunInputId { get; set; } +} + +public sealed class TransferRemainderRequest +{ + [Range(1, int.MaxValue)] + public int RunOutputId { get; set; } + + [Range(0.0001, double.MaxValue)] + public decimal Qty { get; set; } + + public int? RunInputId { get; set; } +} + +public sealed record TransferResultDto( + int RunStageId, IReadOnlyList Transfers, RunStageDto Stage); + +// --- leftover return --------------------------------------------------------- + +public sealed class ReturnLeftoverRequest +{ + /// + /// Quantity to return, in the item's base UOM — the same unit + /// consumedQty/returnedQty are stored in, since the return posts straight + /// to stock. Cannot exceed consumed − already returned. + /// + [Range(0.0001, double.MaxValue)] + public decimal Qty { get; set; } + + /// Mandatory, and must be a Production-context reason (FR-MFG-14). + public int? ReasonCodeId { get; set; } +} + +public sealed record ProductionCreatedLayerDto(int LayerId, decimal UnitCost); + +public sealed record ReturnLeftoverResultDto( + int RunInputId, decimal ReturnedQty, decimal ReturnedValue, + ProductionCreatedLayerDto CreatedLayer, IReadOnlyList LedgerRefs, CostPoolDto CostPool); + +// --- rejection / rework ------------------------------------------------------ + +public sealed class RejectRequest +{ + [StringLength(500)] + public string? Note { get; set; } +} + +/// One parent whose delivered work was pulled back by a reject-intake (FR-MFG-15). +public sealed record PulledBackDto( + int RunInputId, int ParentRunStageId, int ParentRunOutputId, + decimal Qty, ProductionStageStatus PriorParentStatus, ProductionStageStatus ParentStatus); + +public sealed record RejectIntakeResultDto( + int RunStageId, ProductionStageStatus Status, + IReadOnlyList PulledBack, RunGraphDto Run); + +public sealed record TerminalRejectResultDto( + int RunStageId, int ReworkCount, RunGraphDto Run); + +// --- cancel ------------------------------------------------------------------ + +public sealed class CancelRunRequest +{ + public int? ReasonCodeId { get; set; } + + [StringLength(500)] + public string? Note { get; set; } +} + +public sealed record CancelReturnDto(int ItemId, decimal Qty, decimal UnitCost, int LayerId); + +/// +/// Scrapped output quantities written off by a cancel. Recorded on the event only — scrap +/// sits on outputs, which never entered stock, so there is nothing to return (FR-MFG-17). +/// +public sealed record ScrapWriteOffDto(int RunOutputId, string Name, decimal Qty); + +public sealed record CancelRunResultDto( + int RunId, ProductionRunStatus Status, + IReadOnlyList Returns, + IReadOnlyList ScrappedWrittenOff, + IReadOnlyList LedgerRefs); diff --git a/Backend/ERPCore/Dtos/Production/TemplateDtos.cs b/Backend/ERPCore/Dtos/Production/TemplateDtos.cs new file mode 100644 index 0000000..d9185f1 --- /dev/null +++ b/Backend/ERPCore/Dtos/Production/TemplateDtos.cs @@ -0,0 +1,177 @@ +using System.ComponentModel.DataAnnotations; +using ERPCore.Domain.Enums; + +namespace ERPCore.Dtos.Production; + +// Production template contract (docs/30-BACKEND-PHASE2.md §D.1). +// +// The `Key` vocabulary: every stage and every output carries a client-facing string key +// alongside its database id. On a GET the key IS the stringified id; on a save the client +// echoes those keys back for rows it kept and mints "tmp-" keys for rows it just +// drew. Edges and Upstream inputs then reference stages/outputs *by key* only, which is +// what lets one payload shape — and one validator — serve both POST (nothing has an id +// yet) and PUT (most things do). + +// --- responses --------------------------------------------------------------- + +/// +/// Row on the template list (docs/30 §D.1 GET /production-templates). +/// +/// +/// StageNames is an addition to the documented shape. The template overview is a +/// canvas showing every template as a production line with its stages left-to-right +/// (docs/21 §1), so it needs the names for every listed row — without them the client would +/// have to fetch each template's full graph just to label the boxes. Ordered by stage id, +/// matching the graph endpoint. +/// +public sealed record TemplateSummaryDto( + int TemplateId, string Code, string Name, EntityStatus Status, + int StageCount, IReadOnlyList StageNames, + int ActiveRunCount, int CreatedBy, DateTime CreatedAt); + +/// One custom field definition, serialized verbatim into the stage's field_defs jsonb. +public sealed record FieldDefDto( + string Key, string Label, CustomFieldType Type, IReadOnlyList? Options, bool Required); + +public sealed record StageInputDto( + int InputId, StageInputSource Source, int? ItemId, + int? FromOutputId, string? FromOutputKey, int UomId, decimal QtyPerBatch); + +public sealed record StageOutputDto( + int OutputId, string Key, int? ItemId, string Name, int UomId, decimal QtyPerBatch); + +public sealed record TemplateStageDto( + int StageId, string Key, string Name, string? RoleLabel, int EstimatedMinutes, + decimal PosX, decimal PosY, IReadOnlyList FieldDefs, + IReadOnlyList Inputs, IReadOnlyList Outputs); + +public sealed record TemplateEdgeDto( + int EdgeId, int ParentStageId, int ChildStageId, string ParentKey, string ChildKey); + +/// +/// A canvas-only grouping box or divider line. Round-tripped verbatim: no server-side +/// meaning whatsoever, and invisible to the graph validator. +/// +public sealed record CanvasAnnotationDto( + string Kind, decimal PosX, decimal PosY, decimal Width, decimal Height, + string? Label, decimal? Rotation); + +/// Full graph (docs/30 §D.1 GET /production-templates/{id}). +/// +/// ActiveRunCount and Annotations are additions to the documented shape. +/// The first is what puts the builder into its edit-locked state (docs/21 §2) and mirrors +/// the condition UpdateAsync enforces — without it the builder would need a second +/// request to the list endpoint just to know whether to disable itself. +/// +public sealed record TemplateGraphDto( + int TemplateId, string Code, string Name, string? Description, EntityStatus Status, + IReadOnlyList Stages, IReadOnlyList Edges, + IReadOnlyList Annotations, int ActiveRunCount, + int CreatedBy, DateTime CreatedAt); + +// --- requests ---------------------------------------------------------------- +// Narrow by design (02-SECURITY §B.6): no status, no ids, no createdBy, no timestamps. +// POST and PUT share this shape; PUT replaces the whole graph. + +public sealed class SaveTemplateRequest +{ + [Required, StringLength(30, MinimumLength = 1)] + public string Code { get; set; } = string.Empty; + + [Required, StringLength(150, MinimumLength = 1)] + public string Name { get; set; } = string.Empty; + + [StringLength(500)] + public string? Description { get; set; } + + [Required, MinLength(1)] + public List Stages { get; set; } = new(); + + /// Empty is legal — a single-stage template is both entry and terminal. + public List Edges { get; set; } = new(); + + /// + /// Canvas boxes/lines. Capped because this is free-form client state going into a jsonb + /// column — a hand-rolled request should not be able to store an unbounded blob. + /// + [MaxLength(200)] + public List Annotations { get; set; } = new(); +} + +public sealed class SaveStageRequest +{ + /// Existing stage id as a string, or a client-minted tmp-* key for a new stage. + [Required, StringLength(60, MinimumLength = 1)] + public string Key { get; set; } = string.Empty; + + [Required, StringLength(150, MinimumLength = 1)] + public string Name { get; set; } = string.Empty; + + [StringLength(60)] + public string? RoleLabel { get; set; } + + [Range(0, 1_000_000)] + public int EstimatedMinutes { get; set; } + + /// Canvas coordinates, stored verbatim and never interpreted server-side. + public decimal PosX { get; set; } + public decimal PosY { get; set; } + + public List FieldDefs { get; set; } = new(); + public List Inputs { get; set; } = new(); + public List Outputs { get; set; } = new(); +} + +public sealed class SaveInputRequest +{ + [Required] + public StageInputSource Source { get; set; } + + /// Required when is Stock; must be null when Upstream. + public int? ItemId { get; set; } + + /// Required when is Upstream; must name an output of a direct parent. + [StringLength(60)] + public string? FromOutputKey { get; set; } + + [Range(1, int.MaxValue)] + public int UomId { get; set; } + + [Range(0.0001, double.MaxValue)] + public decimal QtyPerBatch { get; set; } +} + +public sealed class SaveOutputRequest +{ + /// Existing output id as a string, or a tmp-* key. Referenced by Upstream inputs. + [Required, StringLength(60, MinimumLength = 1)] + public string Key { get; set; } = string.Empty; + + /// Required on the terminal stage's single output; must be null on every other output. + public int? ItemId { get; set; } + + [Required, StringLength(150, MinimumLength = 1)] + public string Name { get; set; } = string.Empty; + + [Range(1, int.MaxValue)] + public int UomId { get; set; } + + [Range(0.0001, double.MaxValue)] + public decimal QtyPerBatch { get; set; } +} + +public sealed class SaveEdgeRequest +{ + [Required, StringLength(60, MinimumLength = 1)] + public string ParentKey { get; set; } = string.Empty; + + [Required, StringLength(60, MinimumLength = 1)] + public string ChildKey { get; set; } = string.Empty; +} + +/// Body of PATCH /production-templates/{id}/status (docs/30 §D.1). +public sealed class UpdateTemplateStatusRequest +{ + [Required] + public EntityStatus Status { get; set; } +} diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/ProductionConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/ProductionConfiguration.cs new file mode 100644 index 0000000..ca46d0f --- /dev/null +++ b/Backend/ERPCore/Infra/Persistence/Configurations/ProductionConfiguration.cs @@ -0,0 +1,277 @@ +using ERPCore.Domain.Entities; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Metadata.Builders; + +namespace ERPCore.Infra.Persistence.Configurations; + +// Manufacturing / Production Lines (docs/30 Part C). All eleven tables live in this one +// file, following the StockConfiguration.cs precedent of grouping an aggregate's +// configurations together. +// +// Cascade shape (deliberate): the two aggregate roots cascade to their own children — +// template → stages/edges → inputs/outputs, run → stages/edges/events → inputs/outputs. +// Every *cross* reference is Restrict, because making them cascade would give EF two +// delete paths to the same table and the model validator rejects that. The consequence +// is an ordering rule for the service layer: when replacing a graph, delete edges before +// stages and inputs before outputs. + +public sealed class ProductionTemplateConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("production_templates"); + builder.HasKey(t => t.TemplateId); + + builder.Property(t => t.Code).IsRequired().HasMaxLength(30); + builder.HasIndex(t => t.Code).IsUnique(); + + builder.Property(t => t.Name).IsRequired().HasMaxLength(150); + builder.Property(t => t.Description).HasMaxLength(500); + + builder.Property(t => t.Status).HasConversion().HasMaxLength(20).IsRequired(); + + // Same jsonb-as-string mapping as TemplateStage.FieldDefs and AuditLog.ChangeSet: a + // typed/owned mapping would make AuditScribe emit audit rows for the nested entries. + builder.Property(t => t.Annotations).HasColumnType("jsonb"); + + builder.Property(t => t.CreatedAt).IsRequired(); + + // PostgreSQL xmin system column as the optimistic concurrency token (ETag). + builder.Property(t => t.RowVersion).IsRowVersion(); + + builder.HasOne(t => t.Creator).WithMany().HasForeignKey(t => t.CreatedBy).OnDelete(DeleteBehavior.Restrict); + + builder.HasIndex(t => t.Status); + } +} + +public sealed class TemplateStageConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("template_stages"); + builder.HasKey(s => s.StageId); + + builder.Property(s => s.Name).IsRequired().HasMaxLength(150); + builder.Property(s => s.RoleLabel).HasMaxLength(60); + builder.Property(s => s.PosX).HasPrecision(18, 4); + builder.Property(s => s.PosY).HasPrecision(18, 4); + builder.Property(s => s.FieldDefs).IsRequired().HasColumnType("jsonb"); + + builder.HasOne(s => s.Template).WithMany(t => t.Stages) + .HasForeignKey(s => s.TemplateId).OnDelete(DeleteBehavior.Cascade); + } +} + +public sealed class StageEdgeConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("stage_edges"); + builder.HasKey(e => e.EdgeId); + + builder.HasOne(e => e.Template).WithMany(t => t.Edges) + .HasForeignKey(e => e.TemplateId).OnDelete(DeleteBehavior.Cascade); + + builder.HasOne(e => e.ParentStage).WithMany() + .HasForeignKey(e => e.ParentStageId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(e => e.ChildStage).WithMany() + .HasForeignKey(e => e.ChildStageId).OnDelete(DeleteBehavior.Restrict); + + // One arrow per ordered pair; self-loops and cycles are rejected by the validator. + builder.HasIndex(e => new { e.ParentStageId, e.ChildStageId }).IsUnique(); + } +} + +public sealed class StageInputConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("stage_inputs"); + builder.HasKey(i => i.InputId); + + builder.Property(i => i.Source).HasConversion().HasMaxLength(20).IsRequired(); + builder.Property(i => i.QtyPerBatch).HasPrecision(18, 4); + + builder.HasOne(i => i.Stage).WithMany(s => s.Inputs) + .HasForeignKey(i => i.StageId).OnDelete(DeleteBehavior.Cascade); + + builder.HasOne(i => i.Item).WithMany().HasForeignKey(i => i.ItemId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(i => i.Uom).WithMany().HasForeignKey(i => i.UomId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(i => i.FromOutput).WithMany() + .HasForeignKey(i => i.FromOutputId).OnDelete(DeleteBehavior.Restrict); + } +} + +public sealed class StageOutputConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("stage_outputs"); + builder.HasKey(o => o.OutputId); + + builder.Property(o => o.Name).IsRequired().HasMaxLength(150); + builder.Property(o => o.QtyPerBatch).HasPrecision(18, 4); + + builder.HasOne(o => o.Stage).WithMany(s => s.Outputs) + .HasForeignKey(o => o.StageId).OnDelete(DeleteBehavior.Cascade); + + builder.HasOne(o => o.Item).WithMany().HasForeignKey(o => o.ItemId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(o => o.Uom).WithMany().HasForeignKey(o => o.UomId).OnDelete(DeleteBehavior.Restrict); + } +} + +public sealed class ProductionRunConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("production_runs"); + builder.HasKey(r => r.RunId); + + builder.Property(r => r.DocNo).IsRequired().HasMaxLength(30); + builder.HasIndex(r => r.DocNo).IsUnique(); + + builder.Property(r => r.TargetQty).HasPrecision(18, 4); + builder.Property(r => r.ScaleFactor).HasPrecision(18, 6); + builder.Property(r => r.Status).HasConversion().HasMaxLength(20).IsRequired(); + builder.Property(r => r.CreatedAt).IsRequired(); + builder.Property(r => r.RowVersion).IsRowVersion(); + + builder.HasOne(r => r.Template).WithMany(t => t.Runs) + .HasForeignKey(r => r.TemplateId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(r => r.Warehouse).WithMany().HasForeignKey(r => r.WarehouseId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(r => r.OutputBin).WithMany().HasForeignKey(r => r.OutputBinId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(r => r.CancelReason).WithMany().HasForeignKey(r => r.CancelReasonCodeId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(r => r.Creator).WithMany().HasForeignKey(r => r.CreatedBy).OnDelete(DeleteBehavior.Restrict); + + // Run board filters (docs/30 §D.2) and the template edit-lock count (FR-MFG-06). + builder.HasIndex(r => r.Status); + builder.HasIndex(r => new { r.TemplateId, r.Status }); + } +} + +public sealed class RunStageConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("run_stages"); + builder.HasKey(s => s.RunStageId); + + builder.Property(s => s.Name).IsRequired().HasMaxLength(150); + builder.Property(s => s.RoleLabel).HasMaxLength(60); + builder.Property(s => s.PosX).HasPrecision(18, 4); + builder.Property(s => s.PosY).HasPrecision(18, 4); + builder.Property(s => s.Status).HasConversion().HasMaxLength(20).IsRequired(); + builder.Property(s => s.FieldDefs).IsRequired().HasColumnType("jsonb"); + builder.Property(s => s.FieldValues).HasColumnType("jsonb"); + builder.Property(s => s.RowVersion).IsRowVersion(); + + builder.HasOne(s => s.Run).WithMany(r => r.Stages) + .HasForeignKey(s => s.RunId).OnDelete(DeleteBehavior.Cascade); + + // SetNull, not Restrict: a template edit may delete a stage that completed or + // cancelled runs still point at. Everything needed to render such a run is copied + // onto this row, so losing the provenance link is the intended trade (FR-MFG-06). + builder.HasOne(s => s.TemplateStage).WithMany() + .HasForeignKey(s => s.TemplateStageId).OnDelete(DeleteBehavior.SetNull); + + builder.HasIndex(s => new { s.RunId, s.Status }); + } +} + +public sealed class RunEdgeConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("run_edges"); + builder.HasKey(e => e.RunEdgeId); + + builder.HasOne(e => e.Run).WithMany(r => r.Edges) + .HasForeignKey(e => e.RunId).OnDelete(DeleteBehavior.Cascade); + + builder.HasOne(e => e.ParentRunStage).WithMany() + .HasForeignKey(e => e.ParentRunStageId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(e => e.ChildRunStage).WithMany() + .HasForeignKey(e => e.ChildRunStageId).OnDelete(DeleteBehavior.Restrict); + + builder.HasIndex(e => new { e.ParentRunStageId, e.ChildRunStageId }).IsUnique(); + } +} + +public sealed class RunStageInputConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("run_stage_inputs"); + builder.HasKey(i => i.RunInputId); + + builder.Property(i => i.Source).HasConversion().HasMaxLength(20).IsRequired(); + builder.Property(i => i.PlannedQty).HasPrecision(18, 4); + builder.Property(i => i.ConsumedQty).HasPrecision(18, 4); + builder.Property(i => i.ConsumedValue).HasPrecision(18, 4); + builder.Property(i => i.DeliveredQty).HasPrecision(18, 4); + builder.Property(i => i.ReturnedQty).HasPrecision(18, 4); + builder.Property(i => i.ReturnedValue).HasPrecision(18, 4); + + builder.HasOne(i => i.RunStage).WithMany(s => s.Inputs) + .HasForeignKey(i => i.RunStageId).OnDelete(DeleteBehavior.Cascade); + + builder.HasOne(i => i.Item).WithMany().HasForeignKey(i => i.ItemId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(i => i.Uom).WithMany().HasForeignKey(i => i.UomId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(i => i.FromRunOutput).WithMany() + .HasForeignKey(i => i.FromRunOutputId).OnDelete(DeleteBehavior.Restrict); + + // Transfers route by the source output, so this is the hot lookup. + builder.HasIndex(i => i.FromRunOutputId); + } +} + +public sealed class RunStageOutputConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("run_stage_outputs"); + builder.HasKey(o => o.RunOutputId); + + builder.Property(o => o.Name).IsRequired().HasMaxLength(150); + builder.Property(o => o.PlannedQty).HasPrecision(18, 4); + builder.Property(o => o.ProducedQty).HasPrecision(18, 4); + builder.Property(o => o.ScrappedQty).HasPrecision(18, 4); + builder.Property(o => o.TransferredQty).HasPrecision(18, 4); + + builder.HasOne(o => o.RunStage).WithMany(s => s.Outputs) + .HasForeignKey(o => o.RunStageId).OnDelete(DeleteBehavior.Cascade); + + builder.HasOne(o => o.Item).WithMany().HasForeignKey(o => o.ItemId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(o => o.Uom).WithMany().HasForeignKey(o => o.UomId).OnDelete(DeleteBehavior.Restrict); + builder.HasOne(o => o.ScrapReason).WithMany().HasForeignKey(o => o.ScrapReasonCodeId).OnDelete(DeleteBehavior.Restrict); + } +} + +public sealed class RunStageEventConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + // Append-only history: the app never updates or deletes these rows. + builder.ToTable("run_stage_events"); + builder.HasKey(e => e.EventId); + + builder.Property(e => e.EventType).HasConversion().HasMaxLength(20).IsRequired(); + builder.Property(e => e.Note).HasMaxLength(500); + builder.Property(e => e.Payload).HasColumnType("jsonb"); + builder.Property(e => e.CreatedAt).IsRequired(); + + builder.HasOne(e => e.Run).WithMany(r => r.Events) + .HasForeignKey(e => e.RunId).OnDelete(DeleteBehavior.Cascade); + + // SetNull rather than Cascade: the run-level cascade above already removes these + // rows, and a second cascade path (run → stage → event) is what EF rejects. + builder.HasOne(e => e.RunStage).WithMany(s => s.Events) + .HasForeignKey(e => e.RunStageId).OnDelete(DeleteBehavior.SetNull); + + builder.HasOne(e => e.User).WithMany().HasForeignKey(e => e.UserId).OnDelete(DeleteBehavior.Restrict); + + // The run-detail timeline reads the whole run's history in one ordered pass. + builder.HasIndex(e => new { e.RunId, e.EventId }); + } +} diff --git a/Backend/ERPCore/Infra/Persistence/DataSeeder.cs b/Backend/ERPCore/Infra/Persistence/DataSeeder.cs index 79a2352..8972da9 100644 --- a/Backend/ERPCore/Infra/Persistence/DataSeeder.cs +++ b/Backend/ERPCore/Infra/Persistence/DataSeeder.cs @@ -30,6 +30,12 @@ public static class DataSeeder ("WRONG", "Wrong Item", ReasonContext.Return), ("OVER", "Over-supply", ReasonContext.Return), ("QREJ", "Quality Reject", ReasonContext.Return), + // Manufacturing (docs/30 §A.2) — scrap at stage complete, leftover return before + // receipt, and the mandatory reason on a run cancel. + ("PRD-SCRAP", "Production Scrap", ReasonContext.Production), + ("PRD-LEFTOVER", "Production Leftover Return", ReasonContext.Production), + ("PRD-CANCEL", "Production Run Cancelled", ReasonContext.Production), + ("PRD-REWORK-LOSS", "Production Rework Loss", ReasonContext.Production), ]; public static async Task SeedAsync(ErpDbContext db, CancellationToken ct = default) diff --git a/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs b/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs index 06cb8e9..ca895cd 100644 --- a/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs +++ b/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs @@ -126,6 +126,21 @@ public class ErpDbContext : DbContext public DbSet PayrollLineComponents => Set(); public DbSet Payslips => Set(); + // --- Manufacturing: production templates (docs/30-BACKEND-PHASE2.md Part C) --- + public DbSet ProductionTemplates => Set(); + public DbSet TemplateStages => Set(); + public DbSet StageEdges => Set(); + public DbSet StageInputs => Set(); + public DbSet StageOutputs => Set(); + + // --- Manufacturing: production runs (docs/30-BACKEND-PHASE2.md Part C) --- + public DbSet ProductionRuns => Set(); + public DbSet RunStages => Set(); + public DbSet RunEdges => Set(); + public DbSet RunStageInputs => Set(); + public DbSet RunStageOutputs => Set(); + public DbSet RunStageEvents => Set(); + protected override void OnModelCreating(ModelBuilder modelBuilder) { base.OnModelCreating(modelBuilder); diff --git a/Backend/ERPCore/Infra/Persistence/Migrations/ErpDbContextModelSnapshot.cs b/Backend/ERPCore/Infra/Persistence/Migrations/ErpDbContextModelSnapshot.cs index 42c26b7..c484971 100644 --- a/Backend/ERPCore/Infra/Persistence/Migrations/ErpDbContextModelSnapshot.cs +++ b/Backend/ERPCore/Infra/Persistence/Migrations/ErpDbContextModelSnapshot.cs @@ -2400,6 +2400,136 @@ namespace ERPCore.Infra.Persistence.Migrations }); }); + modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b => + { + b.Property("RunId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("RunId")); + + b.Property("CancelReasonCodeId") + .HasColumnType("integer"); + + b.Property("CompletedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("CreatedBy") + .HasColumnType("integer"); + + b.Property("DocNo") + .IsRequired() + .HasMaxLength(30) + .HasColumnType("character varying(30)"); + + b.Property("OutputBinId") + .HasColumnType("integer"); + + b.Property("ReworkCount") + .HasColumnType("integer"); + + b.Property("RowVersion") + .IsConcurrencyToken() + .ValueGeneratedOnAddOrUpdate() + .HasColumnType("xid") + .HasColumnName("xmin"); + + b.Property("ScaleFactor") + .HasPrecision(18, 6) + .HasColumnType("numeric(18,6)"); + + b.Property("Status") + .IsRequired() + .HasMaxLength(20) + .HasColumnType("character varying(20)"); + + b.Property("TargetQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("TemplateId") + .HasColumnType("integer"); + + b.Property("WarehouseId") + .HasColumnType("integer"); + + b.HasKey("RunId"); + + b.HasIndex("CancelReasonCodeId"); + + b.HasIndex("CreatedBy"); + + b.HasIndex("DocNo") + .IsUnique(); + + b.HasIndex("OutputBinId"); + + b.HasIndex("Status"); + + b.HasIndex("WarehouseId"); + + b.HasIndex("TemplateId", "Status"); + + b.ToTable("production_runs", (string)null); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b => + { + b.Property("TemplateId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("TemplateId")); + + b.Property("Annotations") + .HasColumnType("jsonb"); + + b.Property("Code") + .IsRequired() + .HasMaxLength(30) + .HasColumnType("character varying(30)"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("CreatedBy") + .HasColumnType("integer"); + + b.Property("Description") + .HasMaxLength(500) + .HasColumnType("character varying(500)"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(150) + .HasColumnType("character varying(150)"); + + b.Property("RowVersion") + .IsConcurrencyToken() + .ValueGeneratedOnAddOrUpdate() + .HasColumnType("xid") + .HasColumnName("xmin"); + + b.Property("Status") + .IsRequired() + .HasMaxLength(20) + .HasColumnType("character varying(20)"); + + b.HasKey("TemplateId"); + + b.HasIndex("Code") + .IsUnique(); + + b.HasIndex("CreatedBy"); + + b.HasIndex("Status"); + + b.ToTable("production_templates", (string)null); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b => { b.Property("PoId") @@ -2769,6 +2899,261 @@ namespace ERPCore.Infra.Persistence.Migrations b.ToTable("role_permissions", (string)null); }); + modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b => + { + b.Property("RunEdgeId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("RunEdgeId")); + + b.Property("ChildRunStageId") + .HasColumnType("integer"); + + b.Property("ParentRunStageId") + .HasColumnType("integer"); + + b.Property("RunId") + .HasColumnType("integer"); + + b.HasKey("RunEdgeId"); + + b.HasIndex("ChildRunStageId"); + + b.HasIndex("RunId"); + + b.HasIndex("ParentRunStageId", "ChildRunStageId") + .IsUnique(); + + b.ToTable("run_edges", (string)null); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b => + { + b.Property("RunStageId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("RunStageId")); + + b.Property("ActualEndAt") + .HasColumnType("timestamp with time zone"); + + b.Property("ActualStartAt") + .HasColumnType("timestamp with time zone"); + + b.Property("EstimatedMinutes") + .HasColumnType("integer"); + + b.Property("FieldDefs") + .IsRequired() + .HasColumnType("jsonb"); + + b.Property("FieldValues") + .HasColumnType("jsonb"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(150) + .HasColumnType("character varying(150)"); + + b.Property("PosX") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("PosY") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("RoleLabel") + .HasMaxLength(60) + .HasColumnType("character varying(60)"); + + b.Property("RowVersion") + .IsConcurrencyToken() + .ValueGeneratedOnAddOrUpdate() + .HasColumnType("xid") + .HasColumnName("xmin"); + + b.Property("RunId") + .HasColumnType("integer"); + + b.Property("Status") + .IsRequired() + .HasMaxLength(20) + .HasColumnType("character varying(20)"); + + b.Property("TemplateStageId") + .HasColumnType("integer"); + + b.HasKey("RunStageId"); + + b.HasIndex("TemplateStageId"); + + b.HasIndex("RunId", "Status"); + + b.ToTable("run_stages", (string)null); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b => + { + b.Property("EventId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("EventId")); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("EventType") + .IsRequired() + .HasMaxLength(20) + .HasColumnType("character varying(20)"); + + b.Property("Note") + .HasMaxLength(500) + .HasColumnType("character varying(500)"); + + b.Property("Payload") + .HasColumnType("jsonb"); + + b.Property("RunId") + .HasColumnType("integer"); + + b.Property("RunStageId") + .HasColumnType("integer"); + + b.Property("UserId") + .HasColumnType("integer"); + + b.HasKey("EventId"); + + b.HasIndex("RunStageId"); + + b.HasIndex("UserId"); + + b.HasIndex("RunId", "EventId"); + + b.ToTable("run_stage_events", (string)null); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b => + { + b.Property("RunInputId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("RunInputId")); + + b.Property("ConsumedQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("ConsumedValue") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("DeliveredQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("FromRunOutputId") + .HasColumnType("integer"); + + b.Property("ItemId") + .HasColumnType("integer"); + + b.Property("PlannedQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("ReturnedQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("ReturnedValue") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("RunStageId") + .HasColumnType("integer"); + + b.Property("Source") + .IsRequired() + .HasMaxLength(20) + .HasColumnType("character varying(20)"); + + b.Property("UomId") + .HasColumnType("integer"); + + b.HasKey("RunInputId"); + + b.HasIndex("FromRunOutputId"); + + b.HasIndex("ItemId"); + + b.HasIndex("RunStageId"); + + b.HasIndex("UomId"); + + b.ToTable("run_stage_inputs", (string)null); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b => + { + b.Property("RunOutputId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("RunOutputId")); + + b.Property("ItemId") + .HasColumnType("integer"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(150) + .HasColumnType("character varying(150)"); + + b.Property("PlannedQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("ProducedQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("RunStageId") + .HasColumnType("integer"); + + b.Property("ScrapReasonCodeId") + .HasColumnType("integer"); + + b.Property("ScrappedQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("TransferredQty") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("UomId") + .HasColumnType("integer"); + + b.HasKey("RunOutputId"); + + b.HasIndex("ItemId"); + + b.HasIndex("RunStageId"); + + b.HasIndex("ScrapReasonCodeId"); + + b.HasIndex("UomId"); + + b.ToTable("run_stage_outputs", (string)null); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b => { b.Property("SalaryComponentId") @@ -2856,6 +3241,114 @@ namespace ERPCore.Infra.Persistence.Migrations b.ToTable("serials", (string)null); }); + modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b => + { + b.Property("EdgeId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("EdgeId")); + + b.Property("ChildStageId") + .HasColumnType("integer"); + + b.Property("ParentStageId") + .HasColumnType("integer"); + + b.Property("TemplateId") + .HasColumnType("integer"); + + b.HasKey("EdgeId"); + + b.HasIndex("ChildStageId"); + + b.HasIndex("TemplateId"); + + b.HasIndex("ParentStageId", "ChildStageId") + .IsUnique(); + + b.ToTable("stage_edges", (string)null); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b => + { + b.Property("InputId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("InputId")); + + b.Property("FromOutputId") + .HasColumnType("integer"); + + b.Property("ItemId") + .HasColumnType("integer"); + + b.Property("QtyPerBatch") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("Source") + .IsRequired() + .HasMaxLength(20) + .HasColumnType("character varying(20)"); + + b.Property("StageId") + .HasColumnType("integer"); + + b.Property("UomId") + .HasColumnType("integer"); + + b.HasKey("InputId"); + + b.HasIndex("FromOutputId"); + + b.HasIndex("ItemId"); + + b.HasIndex("StageId"); + + b.HasIndex("UomId"); + + b.ToTable("stage_inputs", (string)null); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b => + { + b.Property("OutputId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("OutputId")); + + b.Property("ItemId") + .HasColumnType("integer"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(150) + .HasColumnType("character varying(150)"); + + b.Property("QtyPerBatch") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("StageId") + .HasColumnType("integer"); + + b.Property("UomId") + .HasColumnType("integer"); + + b.HasKey("OutputId"); + + b.HasIndex("ItemId"); + + b.HasIndex("StageId"); + + b.HasIndex("UomId"); + + b.ToTable("stage_outputs", (string)null); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b => { b.Property("AdjustmentId") @@ -3537,6 +4030,48 @@ namespace ERPCore.Infra.Persistence.Migrations b.ToTable("hr_tax_slabs", (string)null); }); + modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b => + { + b.Property("StageId") + .ValueGeneratedOnAdd() + .HasColumnType("integer"); + + NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property("StageId")); + + b.Property("EstimatedMinutes") + .HasColumnType("integer"); + + b.Property("FieldDefs") + .IsRequired() + .HasColumnType("jsonb"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(150) + .HasColumnType("character varying(150)"); + + b.Property("PosX") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("PosY") + .HasPrecision(18, 4) + .HasColumnType("numeric(18,4)"); + + b.Property("RoleLabel") + .HasMaxLength(60) + .HasColumnType("character varying(60)"); + + b.Property("TemplateId") + .HasColumnType("integer"); + + b.HasKey("StageId"); + + b.HasIndex("TemplateId"); + + b.ToTable("template_stages", (string)null); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b => { b.Property("UomId") @@ -4392,6 +4927,58 @@ namespace ERPCore.Infra.Persistence.Migrations b.Navigation("UpdatedByUser"); }); + modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b => + { + b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason") + .WithMany() + .HasForeignKey("CancelReasonCodeId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.User", "Creator") + .WithMany() + .HasForeignKey("CreatedBy") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin") + .WithMany() + .HasForeignKey("OutputBinId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template") + .WithMany("Runs") + .HasForeignKey("TemplateId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse") + .WithMany() + .HasForeignKey("WarehouseId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("CancelReason"); + + b.Navigation("Creator"); + + b.Navigation("OutputBin"); + + b.Navigation("Template"); + + b.Navigation("Warehouse"); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b => + { + b.HasOne("ERPCore.Domain.Entities.User", "Creator") + .WithMany() + .HasForeignKey("CreatedBy") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Creator"); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b => { b.HasOne("ERPCore.Domain.Entities.User", "Creator") @@ -4558,6 +5145,143 @@ namespace ERPCore.Infra.Persistence.Migrations b.Navigation("Role"); }); + modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b => + { + b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage") + .WithMany() + .HasForeignKey("ChildRunStageId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage") + .WithMany() + .HasForeignKey("ParentRunStageId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run") + .WithMany("Edges") + .HasForeignKey("RunId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("ChildRunStage"); + + b.Navigation("ParentRunStage"); + + b.Navigation("Run"); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b => + { + b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run") + .WithMany("Stages") + .HasForeignKey("RunId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage") + .WithMany() + .HasForeignKey("TemplateStageId") + .OnDelete(DeleteBehavior.SetNull); + + b.Navigation("Run"); + + b.Navigation("TemplateStage"); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b => + { + b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run") + .WithMany("Events") + .HasForeignKey("RunId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage") + .WithMany("Events") + .HasForeignKey("RunStageId") + .OnDelete(DeleteBehavior.SetNull); + + b.HasOne("ERPCore.Domain.Entities.User", "User") + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Run"); + + b.Navigation("RunStage"); + + b.Navigation("User"); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b => + { + b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput") + .WithMany() + .HasForeignKey("FromRunOutputId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.Item", "Item") + .WithMany() + .HasForeignKey("ItemId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage") + .WithMany("Inputs") + .HasForeignKey("RunStageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.Uom", "Uom") + .WithMany() + .HasForeignKey("UomId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("FromRunOutput"); + + b.Navigation("Item"); + + b.Navigation("RunStage"); + + b.Navigation("Uom"); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b => + { + b.HasOne("ERPCore.Domain.Entities.Item", "Item") + .WithMany() + .HasForeignKey("ItemId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage") + .WithMany("Outputs") + .HasForeignKey("RunStageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason") + .WithMany() + .HasForeignKey("ScrapReasonCodeId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.Uom", "Uom") + .WithMany() + .HasForeignKey("UomId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Item"); + + b.Navigation("RunStage"); + + b.Navigation("ScrapReason"); + + b.Navigation("Uom"); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b => { b.HasOne("ERPCore.Domain.Entities.Item", "Item") @@ -4569,6 +5293,92 @@ namespace ERPCore.Infra.Persistence.Migrations b.Navigation("Item"); }); + modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b => + { + b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage") + .WithMany() + .HasForeignKey("ChildStageId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage") + .WithMany() + .HasForeignKey("ParentStageId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template") + .WithMany("Edges") + .HasForeignKey("TemplateId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("ChildStage"); + + b.Navigation("ParentStage"); + + b.Navigation("Template"); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b => + { + b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput") + .WithMany() + .HasForeignKey("FromOutputId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.Item", "Item") + .WithMany() + .HasForeignKey("ItemId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage") + .WithMany("Inputs") + .HasForeignKey("StageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.Uom", "Uom") + .WithMany() + .HasForeignKey("UomId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("FromOutput"); + + b.Navigation("Item"); + + b.Navigation("Stage"); + + b.Navigation("Uom"); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b => + { + b.HasOne("ERPCore.Domain.Entities.Item", "Item") + .WithMany() + .HasForeignKey("ItemId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage") + .WithMany("Outputs") + .HasForeignKey("StageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("ERPCore.Domain.Entities.Uom", "Uom") + .WithMany() + .HasForeignKey("UomId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Item"); + + b.Navigation("Stage"); + + b.Navigation("Uom"); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b => { b.HasOne("ERPCore.Domain.Entities.User", "Creator") @@ -4837,6 +5647,17 @@ namespace ERPCore.Infra.Persistence.Migrations b.Navigation("NavItem"); }); + modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b => + { + b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template") + .WithMany("Stages") + .HasForeignKey("TemplateId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Template"); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.UomConversion", b => { b.HasOne("ERPCore.Domain.Entities.Uom", "FromUom") @@ -4954,6 +5775,24 @@ namespace ERPCore.Infra.Persistence.Migrations b.Navigation("Lines"); }); + modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b => + { + b.Navigation("Edges"); + + b.Navigation("Events"); + + b.Navigation("Stages"); + }); + + modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b => + { + b.Navigation("Edges"); + + b.Navigation("Runs"); + + b.Navigation("Stages"); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b => { b.Navigation("Lines"); @@ -4976,6 +5815,15 @@ namespace ERPCore.Infra.Persistence.Migrations b.Navigation("Quotations"); }); + modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b => + { + b.Navigation("Events"); + + b.Navigation("Inputs"); + + b.Navigation("Outputs"); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b => { b.Navigation("Lines"); @@ -4991,6 +5839,13 @@ namespace ERPCore.Infra.Persistence.Migrations b.Navigation("Lines"); }); + modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b => + { + b.Navigation("Inputs"); + + b.Navigation("Outputs"); + }); + modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b => { b.Navigation("Lines"); diff --git a/Backend/ERPCore/Program.cs b/Backend/ERPCore/Program.cs index 4b7ba3e..1a40914 100644 --- a/Backend/ERPCore/Program.cs +++ b/Backend/ERPCore/Program.cs @@ -10,6 +10,7 @@ using ERPCore.Services; using ERPCore.Services.Auth; using ERPCore.Services.Hrm; using ERPCore.Services.Interfaces; +using ERPCore.Services.Production; using ERPCore.Services.Stock; using ERPCore.System.Errors; using Microsoft.AspNetCore.Authentication; @@ -81,6 +82,7 @@ builder.Services.AddScoped(); builder.Services.AddScoped(); // Stock core + goods receipt (docs/11 §4–5) +builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); @@ -136,12 +138,22 @@ builder.Services.AddScoped(); // HRM: Reports (docs/13-BACKEND-HRM-API.md §6) — read-only, no new entities builder.Services.AddScoped(); +// Manufacturing / Production Lines (docs/30-BACKEND-PHASE2.md Part A). Templates stand +// alone; runs consume FifoCostingService for all stock movement. ProductionGraphValidator +// is deliberately unregistered — it is a pure static algorithm, not an injected service. +builder.Services.AddScoped(); +builder.Services.AddScoped(); + // Health checks (EF Core DB) builder.Services.AddHealthChecks().AddDbContextCheck(); // Swagger / OpenAPI (Swashbuckle v10 → OpenAPI 3.1) builder.Services.AddEndpointsApiExplorer(); -builder.Services.AddSwaggerGen(o => o.SwaggerDoc("v1", new OpenApiInfo { Title = "ERPCore API", Version = "v1" })); +builder.Services.AddSwaggerGen(o => +{ + o.SwaggerDoc("v1", new OpenApiInfo { Title = "ERPCore API", Version = "v1" }); + o.CustomSchemaIds(t => t.FullName!.Replace("+", ".")); +}); var app = builder.Build(); diff --git a/Backend/ERPCore/Services/GrnService.cs b/Backend/ERPCore/Services/GrnService.cs index 3da76b1..41b57ad 100644 --- a/Backend/ERPCore/Services/GrnService.cs +++ b/Backend/ERPCore/Services/GrnService.cs @@ -33,9 +33,9 @@ public sealed class GrnService : IGrnService private readonly IRepository _bins; private readonly IRepository _vendors; private readonly IRepository _batches; - private readonly IRepository _conversions; private readonly IRepository _layers; private readonly IRepository _ledger; + private readonly IUomConverter _uomConverter; private readonly IFifoCostingService _fifo; private readonly INumberSequenceService _numbers; private readonly ICurrentUser _currentUser; @@ -45,7 +45,7 @@ public sealed class GrnService : IGrnService IRepository grns, IRepository pos, IRepository poLines, IRepository items, IRepository uoms, IRepository warehouses, IRepository bins, IRepository vendors, IRepository batches, - IRepository conversions, IRepository layers, IRepository ledger, + IRepository layers, IRepository ledger, IUomConverter uomConverter, IFifoCostingService fifo, INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow) { _grns = grns; @@ -57,9 +57,9 @@ public sealed class GrnService : IGrnService _bins = bins; _vendors = vendors; _batches = batches; - _conversions = conversions; _layers = layers; _ledger = ledger; + _uomConverter = uomConverter; _fifo = fifo; _numbers = numbers; _currentUser = currentUser; @@ -345,19 +345,14 @@ public sealed class GrnService : IGrnService return created; // linked via GrnLine.Batch navigation; FK fixed up on SaveChanges } - private async Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync( + /// + /// Delegates to the shared . This was a private method here + /// until manufacturing needed the same conversion for stage stock inputs; behaviour is + /// identical, so receive costing is unchanged. + /// + private Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync( Item item, int uomId, decimal qty, decimal unitCostPerUom, CancellationToken ct) - { - if (uomId == item.BaseUomId) - return (qty, unitCostPerUom); - - var conv = await _conversions.Query().AsNoTracking() - .FirstOrDefaultAsync(c => c.ItemId == item.ItemId && c.FromUomId == uomId && c.ToUomId == item.BaseUomId, ct) - ?? throw new DomainException(ErrorCodes.Validation, - $"No UOM conversion from {uomId} to base UOM {item.BaseUomId} for item {item.ItemId}.", 422); - - return (qty * conv.Factor, unitCostPerUom / conv.Factor); - } + => _uomConverter.ToBaseAsync(item, uomId, qty, unitCostPerUom, ct); private async Task UpdatePoStatusAsync(int? poId, CancellationToken ct) { diff --git a/Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs b/Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs index 0f85c37..ac6a715 100644 --- a/Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs +++ b/Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs @@ -29,11 +29,22 @@ public interface IFifoCostingService Task> ConsumeAsync( int itemId, int warehouseId, int? batchId, decimal qtyBase, CancellationToken ct = default); - /// Append an immutable ledger entry (value = qtyBase × unitCost). + /// + /// Append an immutable ledger entry. Value defaults to round(qtyBase × unitCost, 4). + /// + /// + /// Posts this exact value instead of deriving it from qty × unit cost. Needed when the + /// authoritative figure is a total rather than a rate: a production receipt must carry the + /// run's cost pool exactly, but unitCost = pool / goodQty rounds to 6 dp, and at + /// 100+ units that rounding error exceeds the ledger's 4 dp tick — so the derived value + /// would drift from the pool (FR-MFG-13). Also used by leftover and cancel returns, whose + /// value is the exact consumed residual. Omit for every rate-driven movement. + /// Task PostLedgerAsync( int itemId, int warehouseId, int? binId, int? batchId, int? serialId, int userId, Direction direction, decimal qtyBase, decimal unitCost, decimal runningBalance, - string sourceDocType, int sourceDocId, DateTime createdAt, CancellationToken ct = default); + string sourceDocType, int sourceDocId, DateTime createdAt, CancellationToken ct = default, + decimal? valueOverride = null); /// Current on-hand (Σ open-layer qtyRemaining) for an item at a warehouse. Task GetOnHandAsync(int itemId, int warehouseId, CancellationToken ct = default); diff --git a/Backend/ERPCore/Services/Interfaces/IProductionRunService.cs b/Backend/ERPCore/Services/Interfaces/IProductionRunService.cs new file mode 100644 index 0000000..865edb3 --- /dev/null +++ b/Backend/ERPCore/Services/Interfaces/IProductionRunService.cs @@ -0,0 +1,99 @@ +using ERPCore.Common.Http; +using ERPCore.Domain.Enums; +using ERPCore.Dtos.Common; +using ERPCore.Dtos.Production; + +namespace ERPCore.Services.Interfaces; + +/// +/// Production run lifecycle (docs/30 §D.2–D.3, FR-MFG-08..19). Every stock-affecting +/// action runs inside a single ExecuteInTransactionAsync scope and consumes stock +/// only through IFifoCostingService (NFR-02/NFR-05). +/// +public interface IProductionRunService +{ + Task> ListAsync( + PageQuery query, ProductionRunStatus? status, int? templateId, int? warehouseId, + CancellationToken ct = default); + + Task?> GetAsync(int runId, CancellationToken ct = default); + + /// + /// Instantiates a template (FR-MFG-08): copies every stage, input, output and edge, + /// scales all quantities by targetQty / terminalOutputQtyPerBatch, issues a + /// PRD-… document number, and leaves entry stages Ready with the rest Waiting. + /// + Task> CreateAsync(CreateRunRequest request, CancellationToken ct = default); + + /// + /// Per-run quantity override on a stage that has not started + /// (409 STAGE_NOT_EDITABLE once it has). Re-evaluates the stage's readiness, + /// since raising an upstream input's planned quantity can un-ready it. + /// + Task UpdateStageQuantitiesAsync( + int runId, int runStageId, UpdateStageQuantitiesRequest request, CancellationToken ct = default); + + /// + /// Ready → InProgress (FR-MFG-10). FIFO-consumes every Stock input from the run + /// warehouse in one transaction and stamps actualStartAt. + /// Consumes max(0, plannedBase − consumedQty) per input, so a rework + /// restart with an unchanged planned quantity consumes nothing and one with a raised + /// planned quantity consumes only the delta (FR-MFG-16). + /// + Task StartStageAsync(int runId, int runStageId, CancellationToken ct = default); + + /// + /// InProgress → Done (FR-MFG-11). Records produced and scrapped quantities per + /// output plus the custom field values. A re-complete after a rework overwrites + /// the previous figures rather than adding to them. + /// + Task CompleteStageAsync( + int runId, int runStageId, CompleteStageRequest request, CancellationToken ct = default); + + /// + /// Done → Approved (FR-MFG-12/13). Non-terminal: hands WIP to the children, + /// defaulting to the full available quantity. Terminal: posts the production receipt — + /// a finished-goods layer costed at costPool / goodQty — and completes the run. + /// + Task ApproveStageAsync( + int runId, int runStageId, ApproveStageRequest request, CancellationToken ct = default); + + /// + /// Later partial transfer of a remainder held on an already-Approved stage (FR-MFG-12), + /// never exceeding produced − scrapped − already transferred. + /// + Task TransferAsync( + int runId, int runStageId, TransferRemainderRequest request, CancellationToken ct = default); + + /// + /// Returns unconsumed material to stock before the receipt closes the pool (FR-MFG-14). + /// The inbound layer is created at the weighted cost actually consumed for that + /// input, so the move is cost-preserving and the pool reduces by exactly what leaves it. + /// 409 RUN_COST_CLOSED once the run has completed. + /// + Task ReturnLeftoverAsync( + int runId, int runInputId, ReturnLeftoverRequest request, CancellationToken ct = default); + + /// + /// Downstream reject (FR-MFG-15): this stage rejects the work it received, its delivering + /// parents revert Approved → InProgress with their transferred quantities pulled + /// back, and this stage returns to Waiting. Consumed stock stays consumed. + /// + Task RejectIntakeAsync( + int runId, int runStageId, RejectRequest request, CancellationToken ct = default); + + /// + /// Terminal reject (FR-MFG-16): resets the whole run to its starting stages, increments + /// reworkCount and snapshots the discarded figures into the event history. + /// Already-consumed material remains in the cost pool. + /// + Task RejectTerminalAsync( + int runId, int runStageId, RejectRequest request, CancellationToken ct = default); + + /// + /// Cancels an in-progress run (FR-MFG-17). Net consumed-and-not-returned stock goes back + /// at its consumed weighted cost; scrapped output quantities are written off on the event. + /// 409 RUN_NOT_CANCELLABLE for a completed run. + /// + Task CancelAsync(int runId, CancelRunRequest request, CancellationToken ct = default); +} diff --git a/Backend/ERPCore/Services/Interfaces/IProductionTemplateService.cs b/Backend/ERPCore/Services/Interfaces/IProductionTemplateService.cs new file mode 100644 index 0000000..94667a6 --- /dev/null +++ b/Backend/ERPCore/Services/Interfaces/IProductionTemplateService.cs @@ -0,0 +1,33 @@ +using ERPCore.Common.Http; +using ERPCore.Domain.Enums; +using ERPCore.Dtos.Common; +using ERPCore.Dtos.Production; + +namespace ERPCore.Services.Interfaces; + +/// +/// Production template CRUD and graph validation (docs/30 §D.1, FR-MFG-01..07). +/// +public interface IProductionTemplateService +{ + Task> ListAsync(PageQuery query, EntityStatus? status, CancellationToken ct = default); + + Task?> GetAsync(int templateId, CancellationToken ct = default); + + Task> CreateAsync(SaveTemplateRequest request, CancellationToken ct = default); + + /// + /// Replaces the whole graph. Requires the current row version (If-Match) and is + /// refused with 409 TEMPLATE_IN_USE while any run of this template is + /// InProgress — edit-lock stands in for versioning (FR-MFG-06). + /// + Task> UpdateAsync( + int templateId, SaveTemplateRequest request, uint expectedRowVersion, CancellationToken ct = default); + + /// + /// Activate/deactivate (FR-MFG-01). Deliberately not edit-locked: deactivating is + /// the "never delete a referenced master" path (FR-MD-08) and only stops new runs + /// being started, so it must stay available while runs are in flight. + /// + Task SetStatusAsync(int templateId, EntityStatus status, CancellationToken ct = default); +} diff --git a/Backend/ERPCore/Services/Interfaces/IUomConverter.cs b/Backend/ERPCore/Services/Interfaces/IUomConverter.cs new file mode 100644 index 0000000..14f1a1a --- /dev/null +++ b/Backend/ERPCore/Services/Interfaces/IUomConverter.cs @@ -0,0 +1,35 @@ +using ERPCore.Domain.Entities; + +namespace ERPCore.Services.Interfaces; + +/// +/// Converts a quantity and its per-UOM cost into the item's base UOM. +/// +/// +/// Everything in the FIFO engine — StockLayer, StockLedger, +/// IFifoCostingService.ConsumeAsync — works exclusively in base UOM, while +/// documents let a user enter a line in any UOM the item has a conversion for. This is the +/// one place that bridges the two. +/// Extracted from GrnService's private ToBaseAsync when manufacturing +/// needed the same conversion for stage stock inputs (docs/30 never mentions UOM +/// conversion, but STAGE_INPUT.uom_id is a free FK — without this, an input +/// specified in "Box of 12" would consume 1 base unit instead of 12 and silently +/// mis-cost the run). +/// +public interface IUomConverter +{ + /// + /// Returns the quantity and unit cost restated in 's base UOM. + /// A no-op when already is the base UOM. Throws 422 when no + /// conversion is defined for the item from that UOM to its base. + /// + Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync( + Item item, int uomId, decimal qty, decimal unitCostPerUom, CancellationToken ct = default); + + /// + /// Quantity-only conversion, for callers that have no per-UOM cost to restate (a + /// production stage input declares a quantity; its cost comes from the FIFO layers it + /// consumes, not from the document). + /// + Task ToBaseQtyAsync(Item item, int uomId, decimal qty, CancellationToken ct = default); +} diff --git a/Backend/ERPCore/Services/Production/ProductionGraphValidator.cs b/Backend/ERPCore/Services/Production/ProductionGraphValidator.cs new file mode 100644 index 0000000..bc09891 --- /dev/null +++ b/Backend/ERPCore/Services/Production/ProductionGraphValidator.cs @@ -0,0 +1,211 @@ +using ERPCore.Domain.Enums; +using ERPCore.System.Errors; + +namespace ERPCore.Services.Production; + +/// +/// Validates a template stage graph (FR-MFG-02, FR-MFG-04, FR-MFG-05) and throws the +/// matching 422 GRAPH_* domain error on the first violation. +/// +/// +/// This is an algorithm, not a service — pure, synchronous, no database and +/// no DI, in the spirit of FifoCostingService being the one place FIFO lives. It +/// deliberately has no interface: Services/Interfaces/ exists for things that get +/// injected, and registering this would buy nothing. +/// It works entirely in keys, never database ids, so the identical code path +/// runs for a POST (where nothing has an id yet) and a PUT (where most things do). All +/// database-dependent checks — does this item exist, is it Active, does this UOM exist — +/// stay in ProductionTemplateService so this stays free of I/O. +/// Checks run cheapest-first and fail fast, and every message names the offending +/// stage or edge so the canvas can focus it (docs/21 §2). +/// +public static class ProductionGraphValidator +{ + public sealed record InputDraft(int Index, StageInputSource Source, int? ItemId, string? FromOutputKey); + + public sealed record OutputDraft(string Key, string Name, int? ItemId); + + public sealed record StageDraft( + string Key, string Name, IReadOnlyList Inputs, IReadOnlyList Outputs); + + public readonly record struct EdgeDraft(string ParentKey, string ChildKey); + + /// + /// Throws on the first rule violation; returns silently for a valid graph. + /// + public static void Validate(IReadOnlyList stages, IReadOnlyList edges) + { + // 1 — structural hygiene. These are all blocked in the canvas at draw time + // (docs/21 §2); this is the server backstop for a hand-rolled request. + if (stages.Count == 0) + throw Invalid("A template must have at least one stage."); + + var stageByKey = new Dictionary(StringComparer.Ordinal); + foreach (var s in stages) + { + if (string.IsNullOrWhiteSpace(s.Key)) + throw Invalid("Every stage requires a key."); + if (!stageByKey.TryAdd(s.Key, s)) + throw Invalid($"Duplicate stage key '{s.Key}'."); + } + + // Output keys are unique across the whole template, not just within a stage — + // an Upstream input names one by key alone, so a collision would be ambiguous. + var outputOwner = new Dictionary(StringComparer.Ordinal); + foreach (var s in stages) + foreach (var o in s.Outputs) + { + if (string.IsNullOrWhiteSpace(o.Key)) + throw Invalid($"Every output of stage '{s.Name}' requires a key."); + if (!outputOwner.TryAdd(o.Key, s.Key)) + throw Invalid($"Duplicate output key '{o.Key}' (stage '{s.Name}')."); + } + + var edgeSet = new HashSet<(string, string)>(); + foreach (var e in edges) + { + if (!stageByKey.ContainsKey(e.ParentKey) || !stageByKey.ContainsKey(e.ChildKey)) + throw Invalid($"Edge '{e.ParentKey}' → '{e.ChildKey}' references a stage that is not in the payload."); + if (string.Equals(e.ParentKey, e.ChildKey, StringComparison.Ordinal)) + throw Invalid($"Stage '{stageByKey[e.ParentKey].Name}' cannot connect to itself."); + if (!edgeSet.Add((e.ParentKey, e.ChildKey))) + throw Invalid($"Duplicate edge '{stageByKey[e.ParentKey].Name}' → '{stageByKey[e.ChildKey].Name}'."); + } + + var children = stages.ToDictionary(s => s.Key, _ => new List(), StringComparer.Ordinal); + var parents = stages.ToDictionary(s => s.Key, _ => new List(), StringComparer.Ordinal); + foreach (var (parent, child) in edgeSet) + { + children[parent].Add(child); + parents[child].Add(parent); + } + + // 2 — cycle detection by Kahn's algorithm. If the toposort can't reach every + // stage, the unreached set is exactly the stages trapped in (or downstream of) + // a cycle, which is what the client highlights. + var indegree = stages.ToDictionary(s => s.Key, s => parents[s.Key].Count, StringComparer.Ordinal); + var queue = new Queue(indegree.Where(kv => kv.Value == 0).Select(kv => kv.Key)); + var sorted = 0; + while (queue.Count > 0) + { + var key = queue.Dequeue(); + sorted++; + foreach (var child in children[key]) + if (--indegree[child] == 0) + queue.Enqueue(child); + } + + if (sorted != stages.Count) + { + var trapped = indegree.Where(kv => kv.Value > 0).Select(kv => stageByKey[kv.Key].Name); + throw new DomainException(ErrorCodes.GraphCycle, + $"The stage graph contains a cycle involving: {string.Join(", ", trapped)}.", 422); + } + + // 3 — exactly one terminal stage (multiple starts may converge, but the line must + // end in one place, because that single stage is what receives the finished good). + var terminals = stages.Where(s => children[s.Key].Count == 0).ToList(); + if (terminals.Count != 1) + throw new DomainException(ErrorCodes.GraphTerminalCount, + terminals.Count == 0 + ? "The stage graph has no final stage." + : $"The stage graph must converge to exactly one final stage, but {terminals.Count} have no outgoing connection: {string.Join(", ", terminals.Select(t => t.Name))}.", + 422); + + var terminal = terminals[0]; + var entries = stages.Where(s => parents[s.Key].Count == 0).ToList(); + + // 4 — connectivity. One traversal each way subsumes all three of "no disconnected + // stages", "every stage reachable from an entry" and "every stage reaches the + // terminal": an isolated stage simply appears in neither set. A lone stage is both + // an entry and the terminal, so it falls out correctly with no special case. + // + // Kept as defence in depth, but note it is unreachable once checks 2 and 3 pass: + // in an acyclic graph every stage is reachable from some source, and if exactly one + // stage lacks an outbound edge then every stage necessarily reaches it. An isolated + // stage therefore surfaces as GRAPH_TERMINAL_COUNT (it is a second terminal), which + // is the better message anyway because it names both offenders. Verified by the M2 + // smoke test, which asserts that behaviour explicitly. + var fromEntry = Reach(entries.Select(s => s.Key), children); + var toTerminal = Reach([terminal.Key], parents); + + var stranded = stages.Where(s => !fromEntry.Contains(s.Key) || !toTerminal.Contains(s.Key)).ToList(); + if (stranded.Count > 0) + throw new DomainException(ErrorCodes.GraphDisconnected, + $"Every stage must sit on a path from a starting stage to '{terminal.Name}', but these do not: {string.Join(", ", stranded.Select(s => s.Name))}.", + 422); + + // 5 — input sources (FR-MFG-04). An Upstream input may only draw from an output of + // a DIRECT parent: allowing a grandparent's output would mean WIP skipping a stage. + foreach (var s in stages) + { + var allowed = parents[s.Key] + .SelectMany(p => stageByKey[p].Outputs.Select(o => o.Key)) + .ToHashSet(StringComparer.Ordinal); + + foreach (var input in s.Inputs) + { + if (input.Source == StageInputSource.Upstream) + { + if (input.ItemId is not null) + throw new DomainException(ErrorCodes.GraphInputSourceInvalid, + $"Input {input.Index + 1} of stage '{s.Name}' is Upstream and cannot also reference an item.", 422); + if (string.IsNullOrWhiteSpace(input.FromOutputKey)) + throw new DomainException(ErrorCodes.GraphInputSourceInvalid, + $"Input {input.Index + 1} of stage '{s.Name}' is Upstream but names no source output.", 422); + if (!allowed.Contains(input.FromOutputKey)) + { + var owner = outputOwner.TryGetValue(input.FromOutputKey, out var ownerKey) + ? $"'{stageByKey[ownerKey].Name}' is not a direct parent of '{s.Name}'" + : $"output '{input.FromOutputKey}' does not exist"; + throw new DomainException(ErrorCodes.GraphInputSourceInvalid, + $"Input {input.Index + 1} of stage '{s.Name}' must draw from a direct parent's output — {owner}.", 422); + } + } + else + { + if (input.ItemId is null) + throw new DomainException(ErrorCodes.GraphInputSourceInvalid, + $"Input {input.Index + 1} of stage '{s.Name}' is a Stock input and requires an item.", 422); + if (!string.IsNullOrWhiteSpace(input.FromOutputKey)) + throw new DomainException(ErrorCodes.GraphInputSourceInvalid, + $"Input {input.Index + 1} of stage '{s.Name}' is a Stock input and cannot reference an upstream output.", 422); + } + } + } + + // 6 — outputs (FR-MFG-05). The terminal stage produces exactly one real Item (the + // finished good the receipt creates a layer for); every other output is internal + // WIP and must stay item-less, or it would imply stock that never exists. + if (terminal.Outputs.Count != 1) + throw new DomainException(ErrorCodes.TerminalOutputItemRequired, + $"The final stage '{terminal.Name}' must have exactly one output, but has {terminal.Outputs.Count}.", 422); + + if (terminal.Outputs[0].ItemId is null) + throw new DomainException(ErrorCodes.TerminalOutputItemRequired, + $"The output of the final stage '{terminal.Name}' must reference the finished item.", 422); + + foreach (var s in stages.Where(s => !ReferenceEquals(s, terminal))) + foreach (var o in s.Outputs.Where(o => o.ItemId is not null)) + throw Invalid( + $"Output '{o.Name}' of stage '{s.Name}' is intermediate work-in-progress and cannot reference an item — only the final stage produces a stocked item."); + } + + /// Set of keys reachable from following . + private static HashSet Reach(IEnumerable roots, Dictionary> next) + { + var seen = new HashSet(roots, StringComparer.Ordinal); + var queue = new Queue(seen); + while (queue.Count > 0) + foreach (var n in next[queue.Dequeue()]) + if (seen.Add(n)) + queue.Enqueue(n); + return seen; + } + + /// + /// Structural violations the client already prevents and docs/30 §D.4 assigns no + /// dedicated code to — still 422, still carrying a message that names the culprit. + /// + private static DomainException Invalid(string message) => new(ErrorCodes.Validation, message, 422); +} diff --git a/Backend/ERPCore/Services/Production/ProductionJson.cs b/Backend/ERPCore/Services/Production/ProductionJson.cs new file mode 100644 index 0000000..1ddba58 --- /dev/null +++ b/Backend/ERPCore/Services/Production/ProductionJson.cs @@ -0,0 +1,41 @@ +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace ERPCore.Services.Production; + +/// +/// The one serializer for every jsonb column in the manufacturing module — +/// template_stages.field_defs, run_stages.field_defs/field_values +/// and run_stage_events.payload. +/// +/// +/// Those columns hold a pre-serialized string rather than a mapped POCO, +/// following the AuditLog.ChangeSet precedent. Beyond consistency this keeps +/// AuditScribe honest: an owned/typed jsonb mapping would surface the nested +/// objects as their own change-tracker entries and scatter spurious audit rows across +/// the new tables. +/// Everything is written through here so a column can only ever contain canonical +/// JSON — the raw client string is never stored, which means a malformed +/// fieldDefs can't reach the database and can't later break a run created from +/// that template. +/// +public static class ProductionJson +{ + /// Matches the API's own wire format (docs/11 §1.3): camelCase, enums as strings. + public static readonly JsonSerializerOptions Options = new() + { + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull, + Converters = { new JsonStringEnumConverter() } + }; + + public static string Serialize(T value) => JsonSerializer.Serialize(value, Options); + + /// + /// Reads a stored column back. Returns for null/blank so a + /// caller never has to null-check; a parse failure is a genuine data-integrity problem + /// and is allowed to throw. + /// + public static T Deserialize(string? json, T fallback) + => string.IsNullOrWhiteSpace(json) ? fallback : JsonSerializer.Deserialize(json, Options) ?? fallback; +} diff --git a/Backend/ERPCore/Services/Production/ProductionRunService.cs b/Backend/ERPCore/Services/Production/ProductionRunService.cs new file mode 100644 index 0000000..2d25829 --- /dev/null +++ b/Backend/ERPCore/Services/Production/ProductionRunService.cs @@ -0,0 +1,1258 @@ +using System.Text.Json; +using ERPCore.Common.Http; +using ERPCore.Domain; +using ERPCore.Domain.Entities; +using ERPCore.Domain.Enums; +using ERPCore.Dtos.Common; +using ERPCore.Dtos.Production; +using ERPCore.Infra.Auth; +using ERPCore.Infra.UoW; +using ERPCore.Repositories.Interfaces; +using ERPCore.Services.Interfaces; +using ERPCore.System.Errors; +using Microsoft.EntityFrameworkCore; + +namespace ERPCore.Services.Production; + +/// +/// Production run lifecycle (docs/30 §D.2–D.3, FR-MFG-08..19). +/// +public sealed class ProductionRunService : IProductionRunService +{ + private readonly IRepository _runs; + private readonly IRepository _templates; + private readonly IRepository _warehouses; + private readonly IRepository _bins; + private readonly IRepository _items; + private readonly IRepository _reasonCodes; + private readonly IFifoCostingService _fifo; + private readonly IUomConverter _uomConverter; + private readonly INumberSequenceService _numbers; + private readonly IUnitOfWork _uow; + private readonly ICurrentUser _currentUser; + + public ProductionRunService( + IRepository runs, IRepository templates, + IRepository warehouses, IRepository bins, + IRepository items, IRepository reasonCodes, + IFifoCostingService fifo, IUomConverter uomConverter, + INumberSequenceService numbers, IUnitOfWork uow, ICurrentUser currentUser) + { + _runs = runs; + _templates = templates; + _warehouses = warehouses; + _bins = bins; + _items = items; + _reasonCodes = reasonCodes; + _fifo = fifo; + _uomConverter = uomConverter; + _numbers = numbers; + _uow = uow; + _currentUser = currentUser; + } + + // --- reads --------------------------------------------------------------- + + public async Task> ListAsync( + PageQuery query, ProductionRunStatus? status, int? templateId, int? warehouseId, + CancellationToken ct = default) + { + var q = _runs.Query().AsNoTracking(); + + if (!string.IsNullOrWhiteSpace(query.Q)) + { + var term = query.Q.Trim(); + q = q.Where(r => EF.Functions.ILike(r.DocNo, $"%{term}%")); + } + + if (status is not null) q = q.Where(r => r.Status == status); + if (templateId is not null) q = q.Where(r => r.TemplateId == templateId); + if (warehouseId is not null) q = q.Where(r => r.WarehouseId == warehouseId); + + var total = await q.CountAsync(ct); + + // Projected to an anonymous type first, then mapped client-side. EF Core 10 cannot + // translate a record constructor call that sits inside a projection alongside + // aggregates — the same failure mode already recorded for WarehouseValuationDto in + // Backend/PROGRESS.md (2026-07-28). + var rows = await q + .OrderByDescending(r => r.RunId) // newest first (docs/30 §D.2) + .Skip(query.Skip).Take(query.PageSize) + .Select(r => new + { + r.RunId, + r.DocNo, + r.TemplateId, + TemplateName = r.Template!.Name, + r.TargetQty, + r.Status, + r.ReworkCount, + r.WarehouseId, + Waiting = r.Stages.Count(s => s.Status == ProductionStageStatus.Waiting), + Ready = r.Stages.Count(s => s.Status == ProductionStageStatus.Ready), + InProgress = r.Stages.Count(s => s.Status == ProductionStageStatus.InProgress), + Done = r.Stages.Count(s => s.Status == ProductionStageStatus.Done), + Approved = r.Stages.Count(s => s.Status == ProductionStageStatus.Approved), + // Only the terminal output carries an item, so this is unambiguous. + Finished = r.Stages.SelectMany(s => s.Outputs) + .Where(o => o.ItemId != null) + .Select(o => new { o.ItemId, ItemName = o.Item!.Name }) + .FirstOrDefault(), + r.CreatedBy, + r.CreatedAt, + r.CompletedAt + }) + .ToListAsync(ct); + + var items = rows.Select(r => new RunSummaryDto( + r.RunId, r.DocNo, r.TemplateId, r.TemplateName, r.TargetQty, r.Status, r.ReworkCount, + new StageSummaryDto(r.Waiting, r.Ready, r.InProgress, r.Done, r.Approved), + r.WarehouseId, r.Finished?.ItemId, r.Finished?.ItemName, + r.CreatedBy, r.CreatedAt, r.CompletedAt)).ToList(); + + return PagedResponse.Create(items, query.Page, query.PageSize, total); + } + + public async Task?> GetAsync(int runId, CancellationToken ct = default) + { + var run = await LoadGraphQuery().AsNoTracking().FirstOrDefaultAsync(r => r.RunId == runId, ct); + return run is null ? null : new ETagged(ToGraphDto(run), run.RowVersion); + } + + // --- creation ------------------------------------------------------------ + + public async Task> CreateAsync(CreateRunRequest request, CancellationToken ct = default) + { + var template = await _templates.Query().AsNoTracking() + .Include(t => t.Stages).ThenInclude(s => s.Inputs) + .Include(t => t.Stages).ThenInclude(s => s.Outputs) + .Include(t => t.Edges) + .FirstOrDefaultAsync(t => t.TemplateId == request.TemplateId, ct) + ?? throw new NotFoundException($"Production template {request.TemplateId} was not found."); + + if (template.Status != EntityStatus.Active) + throw new DomainException(ErrorCodes.TemplateInactive, + $"Template '{template.Code}' is inactive and cannot start new runs.", 422); + + if (!await _warehouses.Query().AsNoTracking().AnyAsync(w => w.WarehouseId == request.WarehouseId, ct)) + throw new DomainException(ErrorCodes.Validation, + $"Warehouse {request.WarehouseId} does not exist.", 422); + + if (request.OutputBinId is not null) + { + var binWarehouse = await _bins.Query().AsNoTracking() + .Where(b => b.BinId == request.OutputBinId) + .Select(b => (int?)b.WarehouseId).FirstOrDefaultAsync(ct); + + if (binWarehouse is null) + throw new DomainException(ErrorCodes.Validation, $"Bin {request.OutputBinId} does not exist.", 422); + if (binWarehouse != request.WarehouseId) + throw new DomainException(ErrorCodes.Validation, + $"Bin {request.OutputBinId} belongs to warehouse {binWarehouse}, not {request.WarehouseId}.", 422); + } + + // Re-derive the terminal defensively. The graph was validated when the template was + // saved, but a run is a long-lived copy and starting from a malformed graph would + // produce a run that can never complete. + var hasOutbound = template.Edges.Select(e => e.ParentStageId).ToHashSet(); + var hasInbound = template.Edges.Select(e => e.ChildStageId).ToHashSet(); + var terminals = template.Stages.Where(s => !hasOutbound.Contains(s.StageId)).ToList(); + + if (terminals.Count != 1) + throw new DomainException(ErrorCodes.GraphTerminalCount, + $"Template '{template.Code}' does not have exactly one final stage and cannot be run.", 422); + + var terminalOutput = terminals[0].Outputs.SingleOrDefault() + ?? throw new DomainException(ErrorCodes.TerminalOutputItemRequired, + $"The final stage of template '{template.Code}' must have exactly one output.", 422); + + if (terminalOutput.ItemId is null) + throw new DomainException(ErrorCodes.TerminalOutputItemRequired, + $"The final stage of template '{template.Code}' must produce a real item.", 422); + + if (terminalOutput.QtyPerBatch <= 0) + throw new DomainException(ErrorCodes.Validation, + "The final stage's output quantity per batch must be greater than zero.", 422); + + // Scale from the UNROUNDED ratio and round each quantity once, so a repeating + // scale factor (e.g. 50/3) does not compound its error across every stage. The + // stored ScaleFactor is the same ratio rounded to the column's 6 dp, for display. + var ratio = request.TargetQty / terminalOutput.QtyPerBatch; + + var run = new ProductionRun + { + TemplateId = template.TemplateId, + WarehouseId = request.WarehouseId, + OutputBinId = request.OutputBinId, + TargetQty = request.TargetQty, + ScaleFactor = Math.Round(ratio, 6, MidpointRounding.AwayFromZero), + Status = ProductionRunStatus.InProgress, + ReworkCount = 0, + CreatedBy = _currentUser.AuditUserId, + CreatedAt = DateTime.UtcNow + }; + + // Wired through navigation properties so EF resolves every generated key itself on a + // single SaveChanges — no intermediate saves to materialise ids. + var stageByTemplateStageId = new Dictionary(); + var outputByTemplateOutputId = new Dictionary(); + + // Pass 1 — stages and outputs. + foreach (var ts in template.Stages.OrderBy(s => s.StageId)) + { + var isEntry = !hasInbound.Contains(ts.StageId); + var rs = new RunStage + { + Run = run, + TemplateStageId = ts.StageId, + Name = ts.Name, + RoleLabel = ts.RoleLabel, + EstimatedMinutes = ts.EstimatedMinutes, + PosX = ts.PosX, + PosY = ts.PosY, + // FR-MFG-09: entry stages have nothing to wait for. + Status = isEntry ? ProductionStageStatus.Ready : ProductionStageStatus.Waiting, + FieldDefs = ts.FieldDefs, + FieldValues = null + }; + run.Stages.Add(rs); + stageByTemplateStageId[ts.StageId] = rs; + + foreach (var o in ts.Outputs.OrderBy(o => o.OutputId)) + { + var ro = new RunStageOutput + { + RunStage = rs, + ItemId = o.ItemId, + Name = o.Name, + UomId = o.UomId, + PlannedQty = Scale(o.QtyPerBatch, ratio) + }; + rs.Outputs.Add(ro); + outputByTemplateOutputId[o.OutputId] = ro; + } + } + + // Pass 2 — inputs, which may point at any output built above. + foreach (var ts in template.Stages.OrderBy(s => s.StageId)) + { + var rs = stageByTemplateStageId[ts.StageId]; + foreach (var i in ts.Inputs.OrderBy(i => i.InputId)) + { + rs.Inputs.Add(new RunStageInput + { + RunStage = rs, + Source = i.Source, + ItemId = i.ItemId, + FromRunOutput = i.FromOutputId is null ? null : outputByTemplateOutputId[i.FromOutputId.Value], + UomId = i.UomId, + PlannedQty = Scale(i.QtyPerBatch, ratio) + }); + } + } + + // Pass 3 — edges, copied so a later template edit can never rewrite this run's shape. + foreach (var e in template.Edges) + { + run.Edges.Add(new RunEdge + { + Run = run, + ParentRunStage = stageByTemplateStageId[e.ParentStageId], + ChildRunStage = stageByTemplateStageId[e.ChildStageId] + }); + } + + await _uow.ExecuteInTransactionAsync(async token => + { + // Must be inside the transaction — NumberSequenceService enlists in it. + run.DocNo = await _numbers.NextAsync(DocumentTypes.Production, token); + await _runs.AddAsync(run, token); + }, ct); + + return await GetAsync(run.RunId, ct) + ?? throw new NotFoundException($"Production run {run.RunId} was not found after creation."); + } + + private static decimal Scale(decimal qtyPerBatch, decimal ratio) + => Math.Round(qtyPerBatch * ratio, 4, MidpointRounding.AwayFromZero); + + // --- quantity override --------------------------------------------------- + + public async Task UpdateStageQuantitiesAsync( + int runId, int runStageId, UpdateStageQuantitiesRequest request, CancellationToken ct = default) + { + RunStage? stage = null; + + await _uow.ExecuteInTransactionAsync(async token => + { + var run = await LoadGraphQuery().FirstOrDefaultAsync(r => r.RunId == runId, token) + ?? throw new NotFoundException($"Production run {runId} was not found."); + + if (run.Status != ProductionRunStatus.InProgress) + throw new ConflictException($"Run {run.DocNo} is {run.Status}; quantities can only be edited while it is in progress."); + + stage = run.Stages.FirstOrDefault(s => s.RunStageId == runStageId) + ?? throw new NotFoundException($"Stage {runStageId} is not part of run {runId}."); + + // FR-MFG-08: editable until the stage starts. Once started, consumption has + // already happened against the planned figures. + if (stage.Status is not (ProductionStageStatus.Waiting or ProductionStageStatus.Ready)) + throw new DomainException(ErrorCodes.StageNotEditable, + $"Stage '{stage.Name}' is {stage.Status}; quantities can only be edited before it starts.", 409); + + foreach (var line in request.Inputs) + { + var input = stage.Inputs.FirstOrDefault(i => i.RunInputId == line.Id) + ?? throw new DomainException(ErrorCodes.Validation, + $"Input {line.Id} is not on stage '{stage.Name}'.", 422); + input.PlannedQty = line.PlannedQty; + } + + foreach (var line in request.Outputs) + { + var output = stage.Outputs.FirstOrDefault(o => o.RunOutputId == line.Id) + ?? throw new DomainException(ErrorCodes.Validation, + $"Output {line.Id} is not on stage '{stage.Name}'.", 422); + output.PlannedQty = line.PlannedQty; + } + + // Raising an upstream input's planned quantity means the deliveries that made + // this stage Ready no longer cover it, so it must fall back to Waiting. docs/30 + // does not state this; it is the only behaviour consistent with FR-MFG-09. + RecomputeReadiness(stage); + + AddEvent(run, stage, RunStageEventType.QuantityEdit, null, new + { + inputs = request.Inputs.Select(i => new { runInputId = i.Id, plannedQty = i.PlannedQty }), + outputs = request.Outputs.Select(o => new { runOutputId = o.Id, plannedQty = o.PlannedQty }) + }); + }, ct); + + var refreshed = await GetAsync(runId, ct) + ?? throw new NotFoundException($"Production run {runId} was not found."); + return refreshed.Value.Stages.First(s => s.RunStageId == runStageId); + } + + // --- stage actions ------------------------------------------------------- + + public async Task StartStageAsync( + int runId, int runStageId, CancellationToken ct = default) + { + var consumed = new List(); + var ledgerRefs = new List(); + + await _uow.ExecuteInTransactionAsync(async token => + { + var (run, stage) = await LoadForActionAsync(runId, runStageId, token); + + if (stage.Status != ProductionStageStatus.Ready) + throw new DomainException(ErrorCodes.StageNotReady, + $"Stage '{stage.Name}' is {stage.Status}; only a Ready stage can be started.", 409); + + var now = DateTime.UtcNow; + var actor = _currentUser.AuditUserId; + + // Running balances accumulated per item across the loop: layers written in this + // transaction are invisible to GetOnHandAsync until SaveChanges, so two inputs of + // the same item would otherwise both post the same RunningBalance. Same pattern + // as TransferService.DispatchAsync. + var balances = new Dictionary(); + + foreach (var input in stage.Inputs + .Where(i => i.Source == StageInputSource.Stock) + .OrderBy(i => i.RunInputId)) + { + var item = await _items.Query().AsNoTracking() + .FirstOrDefaultAsync(i => i.ItemId == input.ItemId, token) + ?? throw new DomainException(ErrorCodes.Validation, + $"Item {input.ItemId} on stage '{stage.Name}' no longer exists.", 422); + + // PlannedQty is in the input's declared UOM; ConsumedQty is in the item's + // base UOM (the only unit FIFO and the ledger speak). Compare in base. + var plannedBase = await _uomConverter.ToBaseQtyAsync(item, input.UomId, input.PlannedQty, token); + var delta = plannedBase - input.ConsumedQty; + if (delta <= 0) continue; // rework restart with no increase — nothing to draw + + var segments = await _fifo.ConsumeAsync(item.ItemId, run.WarehouseId, null, delta, token); + var value = segments.Sum(s => s.Qty * s.UnitCost); + var unitCost = delta == 0 ? 0m : value / delta; + + if (!balances.TryGetValue(item.ItemId, out var balance)) + balance = await _fifo.GetOnHandAsync(item.ItemId, run.WarehouseId, token); + balance -= delta; + balances[item.ItemId] = balance; + + var entry = await _fifo.PostLedgerAsync( + item.ItemId, run.WarehouseId, binId: null, batchId: null, serialId: null, actor, + Direction.Out, delta, unitCost, balance, + LedgerSourceTypes.ProductionIssue, run.RunId, now, token); + ledgerRefs.Add(entry); + + input.ConsumedQty += delta; + input.ConsumedValue += value; + + consumed.Add(new ConsumedInputDto( + input.RunInputId, item.ItemId, delta, value, + segments.Select(s => new ConsumedLayerDto(s.LayerId, s.Qty, s.UnitCost)).ToList())); + } + + stage.Status = ProductionStageStatus.InProgress; + stage.ActualStartAt = now; + stage.ActualEndAt = null; + + AddEvent(run, stage, RunStageEventType.Start, null, new + { + consumed = consumed.Select(c => new + { + c.RunInputId, c.ItemId, c.Qty, c.Value, + layers = c.ConsumedLayers.Select(l => new { l.LayerId, l.Qty, l.UnitCost }) + }) + }); + }, ct); + + var stageDto = await RequireStageAsync(runId, runStageId, ct); + return new StartStageResultDto( + runStageId, stageDto.Status, stageDto.ActualStartAt, + consumed, ledgerRefs.Select(l => l.LedgerId).ToList(), stageDto); + } + + public async Task CompleteStageAsync( + int runId, int runStageId, CompleteStageRequest request, CancellationToken ct = default) + { + await _uow.ExecuteInTransactionAsync(async token => + { + var (run, stage) = await LoadForActionAsync(runId, runStageId, token); + + if (stage.Status != ProductionStageStatus.InProgress) + throw new DomainException(ErrorCodes.StageNotInProgress, + $"Stage '{stage.Name}' is {stage.Status}; only an in-progress stage can be completed.", 409); + + ValidateRequiredFields(stage, request.FieldValues); + + foreach (var line in request.Outputs) + { + var output = stage.Outputs.FirstOrDefault(o => o.RunOutputId == line.RunOutputId) + ?? throw new DomainException(ErrorCodes.Validation, + $"Output {line.RunOutputId} is not on stage '{stage.Name}'.", 422); + + if (line.ScrappedQty > 0) + { + if (line.ScrapReasonCodeId is null) + throw new DomainException(ErrorCodes.ReasonCodeRequired, + $"A scrap reason code is required for output '{output.Name}'.", 400); + await EnsureProductionReasonAsync(line.ScrapReasonCodeId.Value, token); + } + + var good = line.ProducedQty - line.ScrappedQty; + if (good < 0) + throw new DomainException(ErrorCodes.Validation, + $"Scrapped {line.ScrappedQty} exceeds produced {line.ProducedQty} on output '{output.Name}'.", 422); + + // A re-complete after a rework OVERWRITES rather than accumulates — adding + // would double the produced quantity on every rework pass. Not stated in + // docs/30; recorded as a decision. + if (good < output.TransferredQty) + throw new DomainException(ErrorCodes.TransferExceedsAvailable, + $"Output '{output.Name}' has already transferred {output.TransferredQty}; " + + $"the new good quantity {good} cannot be lower.", 422); + + output.ProducedQty = line.ProducedQty; + output.ScrappedQty = line.ScrappedQty; + output.ScrapReasonCodeId = line.ScrappedQty > 0 ? line.ScrapReasonCodeId : null; + } + + stage.Status = ProductionStageStatus.Done; + stage.ActualEndAt = DateTime.UtcNow; + stage.FieldValues = request.FieldValues is null + ? null + : ProductionJson.Serialize(request.FieldValues); + + AddEvent(run, stage, RunStageEventType.Complete, null, new + { + outputs = request.Outputs.Select(o => new + { + o.RunOutputId, o.ProducedQty, o.ScrappedQty, o.ScrapReasonCodeId + }), + fieldValues = request.FieldValues + }); + }, ct); + + return await RequireStageAsync(runId, runStageId, ct); + } + + public async Task ApproveStageAsync( + int runId, int runStageId, ApproveStageRequest request, CancellationToken ct = default) + { + var transfers = new List(); + var ledgerRefs = new List(); + Receipt? pending = null; + CostPoolDto? costPool = null; + var runStatus = ProductionRunStatus.InProgress; + + await _uow.ExecuteInTransactionAsync(async token => + { + var (run, stage) = await LoadForActionAsync(runId, runStageId, token); + + if (stage.Status != ProductionStageStatus.Done) + throw new DomainException(ErrorCodes.StageNotDone, + $"Stage '{stage.Name}' is {stage.Status}; only a completed stage can be approved.", 409); + + var now = DateTime.UtcNow; + + if (IsTerminal(run, stage)) + { + (pending, costPool, var entry) = await PostReceiptAsync(run, stage, now, token); + ledgerRefs.Add(entry); + + stage.Status = ProductionStageStatus.Approved; + run.Status = ProductionRunStatus.Completed; + run.CompletedAt = now; + runStatus = run.Status; + + // Layer/ledger ids are still 0 here — they are database-generated and only + // populated once this transaction's SaveChanges runs. The event payload and + // the response DTO are therefore both built after the commit, below. + AddEvent(run, stage, RunStageEventType.Approve, null, new + { + itemId = pending.ItemId, + qtyReceived = pending.QtyBase, + unitCost = pending.UnitCost, + value = pending.LedgerValue, + costPool + }); + return; + } + + foreach (var output in stage.Outputs.OrderBy(o => o.RunOutputId)) + { + var available = output.ProducedQty - output.ScrappedQty - output.TransferredQty; + var line = request.Transfers.FirstOrDefault(t => t.RunOutputId == output.RunOutputId); + + // Default is "transfer everything available" (FR-MFG-12); an explicit line + // makes it a partial and leaves the remainder on the stage. + var qty = line?.Qty ?? available; + if (qty <= 0) continue; + + transfers.AddRange(Deliver(run, output, qty, line?.RunInputId, available)); + } + + stage.Status = ProductionStageStatus.Approved; + AddEvent(run, stage, RunStageEventType.Approve, null, new { transfers }); + }, ct); + + var stageDto = await RequireStageAsync(runId, runStageId, ct); + + // Mapped after the commit so the generated layer id is populated (mirrors the + // "map ledger ids after commit" fix recorded for Count/Return in Backend/PROGRESS.md). + var receipt = pending is null + ? null + : new ReceiptDto( + pending.Layer.LayerId, pending.ItemId, pending.WarehouseId, pending.BinId, + pending.QtyBase, pending.UnitCost, pending.LedgerValue); + + return new ApproveStageResultDto( + runStageId, stageDto.Status, runStatus, transfers, + receipt, costPool, ledgerRefs.Select(l => l.LedgerId).ToList(), stageDto); + } + + /// + /// A posted receipt whose layer id is not yet known. Held across the transaction + /// boundary so can be built once EF has assigned the id. + /// + private sealed record Receipt( + StockLayer Layer, int ItemId, int WarehouseId, int? BinId, + decimal QtyBase, decimal UnitCost, decimal LedgerValue); + + public async Task TransferAsync( + int runId, int runStageId, TransferRemainderRequest request, CancellationToken ct = default) + { + var transfers = new List(); + + await _uow.ExecuteInTransactionAsync(async token => + { + var (run, stage) = await LoadForActionAsync(runId, runStageId, token); + + if (stage.Status != ProductionStageStatus.Approved) + throw new ConflictException( + $"Stage '{stage.Name}' is {stage.Status}; a remainder can only be transferred from an approved stage."); + + var output = stage.Outputs.FirstOrDefault(o => o.RunOutputId == request.RunOutputId) + ?? throw new DomainException(ErrorCodes.Validation, + $"Output {request.RunOutputId} is not on stage '{stage.Name}'.", 422); + + var available = output.ProducedQty - output.ScrappedQty - output.TransferredQty; + transfers.AddRange(Deliver(run, output, request.Qty, request.RunInputId, available)); + + AddEvent(run, stage, RunStageEventType.Transfer, null, new { transfers }); + }, ct); + + return new TransferResultDto(runStageId, transfers, await RequireStageAsync(runId, runStageId, ct)); + } + + public async Task ReturnLeftoverAsync( + int runId, int runInputId, ReturnLeftoverRequest request, CancellationToken ct = default) + { + StockLayer? layer = null; + StockLedger? entry = null; + decimal unitCost = 0, returnValue = 0, returnedQty = 0; + CostPoolDto pool = new(0, 0, 0); + + await _uow.ExecuteInTransactionAsync(async token => + { + var run = await LoadGraphQuery().FirstOrDefaultAsync(r => r.RunId == runId, token) + ?? throw new NotFoundException($"Production run {runId} was not found."); + + // The cost pool is closed by the terminal receipt — returning afterwards would + // change a figure the finished layer has already been costed from (FR-MFG-13). + if (run.Status == ProductionRunStatus.Completed) + throw new DomainException(ErrorCodes.RunCostClosed, + $"Run {run.DocNo} is complete; its cost pool is closed to further returns.", 409); + if (run.Status != ProductionRunStatus.InProgress) + throw new ConflictException($"Run {run.DocNo} is {run.Status}; leftovers cannot be returned."); + + var input = run.Stages.SelectMany(s => s.Inputs) + .FirstOrDefault(i => i.RunInputId == runInputId) + ?? throw new NotFoundException($"Input {runInputId} is not part of run {runId}."); + + if (input.Source != StageInputSource.Stock || input.ItemId is null) + throw new DomainException(ErrorCodes.Validation, + "Only a Stock input can be returned — upstream work-in-progress never entered stock.", 422); + + if (input.ConsumedQty <= 0) + throw new DomainException(ErrorCodes.Validation, + "Nothing has been consumed on this input yet, so there is nothing to return.", 422); + + if (request.ReasonCodeId is null) + throw new DomainException(ErrorCodes.ReasonCodeRequired, + "A reason code is required to return leftover material.", 400); + await EnsureProductionReasonAsync(request.ReasonCodeId.Value, token); + + var remaining = input.ConsumedQty - input.ReturnedQty; + if (request.Qty > remaining) + throw new DomainException(ErrorCodes.LeftoverExceedsConsumed, + $"Cannot return {request.Qty}: only {remaining} remains " + + $"(consumed {input.ConsumedQty} - already returned {input.ReturnedQty}).", 422); + + var now = DateTime.UtcNow; + var stage = run.Stages.First(s => s.RunStageId == input.RunStageId); + + // Weighted cost actually consumed for THIS input — cost-preserving by + // construction, so what leaves the pool is exactly what entered it. + var weighted = input.ConsumedValue / input.ConsumedQty; + unitCost = Math.Round(weighted, 6, MidpointRounding.AwayFromZero); + returnedQty = request.Qty; + + // Rounded once, from the UNROUNDED weighted cost. Rounding the rate first and + // then multiplying lets successive partial returns accumulate drift until the + // last one can exceed ConsumedValue. + returnValue = input.ReturnedQty + request.Qty == input.ConsumedQty + // Full return: take the exact residual so the input's contribution to the + // pool lands on precisely zero rather than a rounding crumb. + ? input.ConsumedValue - input.ReturnedValue + : Math.Round(request.Qty * weighted, 4, MidpointRounding.AwayFromZero); + + layer = await _fifo.CreateInboundLayerAsync( + input.ItemId.Value, run.WarehouseId, batchId: null, serialId: null, grnLineId: null, + request.Qty, unitCost, now, token); + + var balance = await _fifo.GetOnHandAsync(input.ItemId.Value, run.WarehouseId, token) + request.Qty; + + // binId stays null: this is raw material going back to general stock, not into the + // run's finished-goods output bin. + entry = await _fifo.PostLedgerAsync( + input.ItemId.Value, run.WarehouseId, binId: null, batchId: null, serialId: null, + _currentUser.AuditUserId, Direction.In, request.Qty, unitCost, balance, + LedgerSourceTypes.ProductionReturn, run.RunId, now, token, valueOverride: returnValue); + + input.ReturnedQty += request.Qty; + input.ReturnedValue += returnValue; + + var consumedTotal = run.Stages.SelectMany(s => s.Inputs).Sum(i => i.ConsumedValue); + var returnedTotal = run.Stages.SelectMany(s => s.Inputs).Sum(i => i.ReturnedValue); + pool = new CostPoolDto(consumedTotal, returnedTotal, consumedTotal - returnedTotal); + + // RUN_STAGE_INPUT has no reason-code column (docs/30 Part C), so the reason lives + // in the event payload. Adequate as an audit trail; a per-input reportable reason + // would need its own line table. + AddEvent(run, stage, RunStageEventType.LeftoverReturn, null, new + { + runInputId, + qty = request.Qty, + unitCost, + value = returnValue, + reasonCodeId = request.ReasonCodeId + }); + }, ct); + + return new ReturnLeftoverResultDto( + runInputId, returnedQty, returnValue, + new ProductionCreatedLayerDto(layer!.LayerId, unitCost), + [entry!.LedgerId], pool); + } + + public async Task RejectIntakeAsync( + int runId, int runStageId, RejectRequest request, CancellationToken ct = default) + { + var pulled = new List(); + + await _uow.ExecuteInTransactionAsync(async token => + { + var (run, stage) = await LoadForActionAsync(runId, runStageId, token); + + // docs/30 §D.3 says Ready only; docs/21 §5 offers the action on "a Ready/Waiting + // stage with deliveries". Allowing both is the reconciliation: a partially + // delivered Waiting stage is a real case, and the delivered intake — not the + // status — is what makes the reject meaningful. + if (stage.Status is not (ProductionStageStatus.Ready or ProductionStageStatus.Waiting)) + throw new DomainException(ErrorCodes.StageRejectInvalid, + $"Stage '{stage.Name}' is {stage.Status}; intake can only be rejected before the stage starts.", 409); + + var delivered = stage.Inputs + .Where(i => i.Source == StageInputSource.Upstream && i.DeliveredQty > 0) + .OrderBy(i => i.RunInputId) + .ToList(); + + if (delivered.Count == 0) + throw new DomainException(ErrorCodes.StageRejectInvalid, + $"Stage '{stage.Name}' has received no work, so there is nothing to reject.", 409); + + foreach (var input in delivered) + { + var parentOutput = run.Stages.SelectMany(s => s.Outputs) + .FirstOrDefault(o => o.RunOutputId == input.FromRunOutputId); + if (parentOutput is null) continue; + + var parentStage = run.Stages.First(s => s.RunStageId == parentOutput.RunStageId); + var priorStatus = parentStage.Status; + + // DECREMENT, never zero. The parent may also have fed a different child; on + // its re-approve, available = produced − scrapped − transferred must still + // account for that other delivery. This decrement is what keeps the model + // self-consistent. + parentOutput.TransferredQty = Math.Max(0, parentOutput.TransferredQty - input.DeliveredQty); + + pulled.Add(new PulledBackDto( + input.RunInputId, parentStage.RunStageId, parentOutput.RunOutputId, + input.DeliveredQty, priorStatus, + priorStatus == ProductionStageStatus.Approved + ? ProductionStageStatus.InProgress + : priorStatus)); + + input.DeliveredQty = 0; + + if (parentStage.Status == ProductionStageStatus.Approved) + { + parentStage.Status = ProductionStageStatus.InProgress; + // Cleared because the stage must be completed again; ActualStartAt is + // deliberately PRESERVED so the original start time stands (FR-MFG-19). + parentStage.ActualEndAt = null; + } + } + + stage.Status = ProductionStageStatus.Waiting; + stage.ActualStartAt = null; + stage.ActualEndAt = null; + RecomputeReadiness(stage); + + AddEvent(run, stage, RunStageEventType.RejectIntake, request.Note, new { pulledBack = pulled }); + }, ct); + + var refreshed = await GetAsync(runId, ct) + ?? throw new NotFoundException($"Production run {runId} was not found."); + return new RejectIntakeResultDto( + runStageId, refreshed.Value.Stages.First(s => s.RunStageId == runStageId).Status, + pulled, refreshed.Value); + } + + public async Task RejectTerminalAsync( + int runId, int runStageId, RejectRequest request, CancellationToken ct = default) + { + var reworkNumber = 0; + + await _uow.ExecuteInTransactionAsync(async token => + { + var (run, stage) = await LoadForActionAsync(runId, runStageId, token); + + if (!IsTerminal(run, stage)) + throw new DomainException(ErrorCodes.StageRejectInvalid, + $"Stage '{stage.Name}' is not the final stage; use reject-intake instead.", 409); + + // Only from Done. Approving the terminal completes the run and closes the cost + // pool, so there is no rework path back from Approved. + if (stage.Status != ProductionStageStatus.Done) + throw new DomainException(ErrorCodes.StageNotDone, + $"Stage '{stage.Name}' is {stage.Status}; only a completed final stage can be rejected.", 409); + + var hasInbound = run.Edges.Select(e => e.ChildRunStageId).ToHashSet(); + reworkNumber = run.ReworkCount + 1; + + // Snapshot BEFORE resetting — one event row for the whole pass, not one per + // stage: reconstructing "what did rework #2 look like" from N rows is painful. + var snapshot = new + { + reworkNumber, + note = request.Note, + rejectedAt = DateTime.UtcNow, + stages = run.Stages.OrderBy(s => s.RunStageId).Select(s => new + { + runStageId = s.RunStageId, + name = s.Name, + status = s.Status.ToString(), + actualStartAt = s.ActualStartAt, + actualEndAt = s.ActualEndAt, + fieldValues = ParseJson(s.FieldValues), + outputs = s.Outputs.OrderBy(o => o.RunOutputId).Select(o => new + { + o.RunOutputId, o.ProducedQty, o.ScrappedQty, o.ScrapReasonCodeId, o.TransferredQty + }), + inputs = s.Inputs.OrderBy(i => i.RunInputId).Select(i => new + { + i.RunInputId, i.DeliveredQty, i.ConsumedQty, i.ConsumedValue, + i.ReturnedQty, i.ReturnedValue + }) + }) + }; + + AddEvent(run, stage, RunStageEventType.TerminalReject, request.Note, snapshot); + + run.ReworkCount = reworkNumber; + + foreach (var s in run.Stages) + { + // Entry stages become Ready, everything else Waiting. + s.Status = hasInbound.Contains(s.RunStageId) + ? ProductionStageStatus.Waiting + : ProductionStageStatus.Ready; + + // A fresh pass: timings and captured field values are cleared so required + // fields must be answered again. FieldDefs, PosX/PosY, Name, RoleLabel, + // EstimatedMinutes and TemplateStageId all persist. + s.ActualStartAt = null; + s.ActualEndAt = null; + s.FieldValues = null; + + foreach (var o in s.Outputs) + { + o.ProducedQty = 0; + o.ScrappedQty = 0; + o.ScrapReasonCodeId = null; + o.TransferredQty = 0; + // PlannedQty PERSISTS — per-run edits must survive the rework, and + // FR-MFG-16 explicitly expects planned quantities to be raised for it. + } + + foreach (var i in s.Inputs) + { + // WIP is gone... + i.DeliveredQty = 0; + // ...but consumed and returned figures PERSIST: already-consumed material + // remains in the cost pool (FR-MFG-16). No stock is reversed, no ledger + // entry is written. The delta rule in StartStageAsync is what makes the + // next start consume only any increase. + } + } + }, ct); + + var refreshed = await GetAsync(runId, ct) + ?? throw new NotFoundException($"Production run {runId} was not found."); + return new TerminalRejectResultDto(runStageId, reworkNumber, refreshed.Value); + } + + public async Task CancelAsync( + int runId, CancelRunRequest request, CancellationToken ct = default) + { + var returns = new List<(StockLayer Layer, int ItemId, decimal Qty, decimal UnitCost)>(); + var writeOffs = new List(); + var ledgerRefs = new List(); + + await _uow.ExecuteInTransactionAsync(async token => + { + var run = await LoadGraphQuery().FirstOrDefaultAsync(r => r.RunId == runId, token) + ?? throw new NotFoundException($"Production run {runId} was not found."); + + if (run.Status != ProductionRunStatus.InProgress) + throw new DomainException(ErrorCodes.RunNotCancellable, + $"Run {run.DocNo} is {run.Status} and cannot be cancelled.", 409); + + if (request.ReasonCodeId is null) + throw new DomainException(ErrorCodes.ReasonCodeRequired, + "A reason code is required to cancel a run.", 400); + await EnsureProductionReasonAsync(request.ReasonCodeId.Value, token); + + var now = DateTime.UtcNow; + var actor = _currentUser.AuditUserId; + + // Same accumulation as TransferService: layers created in this transaction are + // invisible to GetOnHandAsync until SaveChanges, so without this every + // RunningBalance after the first for a repeated item would be wrong. + var balances = new Dictionary(); + + foreach (var input in run.Stages.SelectMany(s => s.Inputs) + .Where(i => i.Source == StageInputSource.Stock && i.ItemId is not null) + .OrderBy(i => i.RunInputId)) + { + var qty = input.ConsumedQty - input.ReturnedQty; + if (qty <= 0) continue; + + var unitCost = Math.Round(input.ConsumedValue / input.ConsumedQty, 6, MidpointRounding.AwayFromZero); + // Exact residual, so the input's pool contribution lands on zero. + var value = input.ConsumedValue - input.ReturnedValue; + + var layer = await _fifo.CreateInboundLayerAsync( + input.ItemId!.Value, run.WarehouseId, batchId: null, serialId: null, grnLineId: null, + qty, unitCost, now, token); + + if (!balances.TryGetValue(input.ItemId.Value, out var balance)) + balance = await _fifo.GetOnHandAsync(input.ItemId.Value, run.WarehouseId, token); + balance += qty; + balances[input.ItemId.Value] = balance; + + var entry = await _fifo.PostLedgerAsync( + input.ItemId.Value, run.WarehouseId, binId: null, batchId: null, serialId: null, + actor, Direction.In, qty, unitCost, balance, + LedgerSourceTypes.ProductionCancelReturn, run.RunId, now, token, + valueOverride: Math.Round(value, 4, MidpointRounding.AwayFromZero)); + + ledgerRefs.Add(entry); + returns.Add((layer, input.ItemId.Value, qty, unitCost)); + + input.ReturnedQty = input.ConsumedQty; + input.ReturnedValue = input.ConsumedValue; + } + + // FR-MFG-17 says "net consumed − returned − scrapped", but scrap is not + // computable at the input level: ScrappedQty lives on OUTPUTS, in output UOM, + // with no per-input scrap anywhere in the model. Physically the doc's intent is + // already satisfied — scrap is recorded against outputs (finished/intermediate + // WIP) which never entered stock, so there is nothing to deduct from an input + // return. The scrapped quantities are recorded as the written-off figure instead. + writeOffs.AddRange(run.Stages.SelectMany(s => s.Outputs) + .Where(o => o.ScrappedQty > 0) + .Select(o => new ScrapWriteOffDto(o.RunOutputId, o.Name, o.ScrappedQty))); + + run.Status = ProductionRunStatus.Cancelled; + run.CancelReasonCodeId = request.ReasonCodeId; + // CompletedAt stays null — a cancelled run never completed. + + AddEvent(run, null, RunStageEventType.Cancel, request.Note, new + { + reasonCodeId = request.ReasonCodeId, + returns = returns.Select(r => new { r.ItemId, r.Qty, r.UnitCost }), + scrappedWrittenOff = writeOffs + }); + }, ct); + + return new CancelRunResultDto( + runId, ProductionRunStatus.Cancelled, + returns.Select(r => new CancelReturnDto(r.ItemId, r.Qty, r.UnitCost, r.Layer.LayerId)).ToList(), + writeOffs, + ledgerRefs.Select(l => l.LedgerId).ToList()); + } + + // --- action helpers ------------------------------------------------------ + + /// + /// Hands of an output to the child inputs that draw from it, and + /// re-evaluates each child's readiness. + /// + /// + /// Routing is by RunStageInput.FromRunOutputId, not by . + /// FR-MFG-12 describes transfers "per outbound edge", but the entity model connects an + /// output to a specific input — an edge can exist with no input drawing from it, and one + /// output can feed inputs on several children. Recorded as a contract clarification. + /// When several inputs draw from one output and no explicit target is named, they + /// are filled in runInputId order up to each one's outstanding need, with any + /// overflow going to the last. Deterministic, and identical to "give it all to the one + /// target" in the overwhelmingly common 1:1 case. + /// WIP quantities are moved at face value in their declared UOM — no conversion. + /// Intermediate outputs are internal work-in-progress with no item and no ledger entry + /// (FR-MFG-04/05), so there is no base UOM to convert to. + /// + private List Deliver( + ProductionRun run, RunStageOutput output, decimal qty, int? explicitInputId, decimal available) + { + if (qty > available) + throw new DomainException(ErrorCodes.TransferExceedsAvailable, + $"Cannot transfer {qty} from output '{output.Name}': only {available} is available " + + $"(produced {output.ProducedQty} - scrapped {output.ScrappedQty} - transferred {output.TransferredQty}).", + 422); + + var targets = run.Stages + .SelectMany(s => s.Inputs) + .Where(i => i.Source == StageInputSource.Upstream && i.FromRunOutputId == output.RunOutputId) + .OrderBy(i => i.RunInputId) + .ToList(); + + if (explicitInputId is not null) + { + targets = targets.Where(i => i.RunInputId == explicitInputId).ToList(); + if (targets.Count == 0) + throw new DomainException(ErrorCodes.Validation, + $"Input {explicitInputId} does not draw from output '{output.Name}'.", 422); + } + + // An output nothing consumes is legal (the graph validator does not require every + // output to be wired). Record the transfer against the output and stop there. + if (targets.Count == 0) + { + output.TransferredQty += qty; + return []; + } + + var results = new List(); + var remaining = qty; + + for (var idx = 0; idx < targets.Count && remaining > 0; idx++) + { + var target = targets[idx]; + var isLast = idx == targets.Count - 1; + var need = target.PlannedQty - target.DeliveredQty; + var give = isLast ? remaining : Math.Min(remaining, Math.Max(need, 0)); + if (give <= 0) continue; + + target.DeliveredQty += give; + remaining -= give; + + var childStage = run.Stages.First(s => s.RunStageId == target.RunStageId); + RecomputeReadiness(childStage); + + results.Add(new TransferDto( + output.RunOutputId, target.RunInputId, childStage.RunStageId, give, + target.DeliveredQty, childStage.Status)); + } + + output.TransferredQty += qty - remaining; + return results; + } + + /// + /// Terminal approve = production receipt (FR-MFG-13): creates the finished-goods layer + /// costed at costPool / goodQty and posts the inbound ledger entry. + /// + private async Task<(Receipt Receipt, CostPoolDto Pool, StockLedger Entry)> PostReceiptAsync( + ProductionRun run, RunStage stage, DateTime now, CancellationToken ct) + { + var output = stage.Outputs.SingleOrDefault() + ?? throw new DomainException(ErrorCodes.TerminalOutputItemRequired, + $"The final stage '{stage.Name}' must have exactly one output.", 422); + + if (output.ItemId is null) + throw new DomainException(ErrorCodes.TerminalOutputItemRequired, + $"The final stage '{stage.Name}' must produce a real item.", 422); + + var good = output.ProducedQty - output.ScrappedQty; + if (good <= 0) + throw new DomainException(ErrorCodes.Validation, + $"The final stage produced no good quantity ({output.ProducedQty} - {output.ScrappedQty}); " + + "there is nothing to receive.", 422); + + var item = await _items.Query().AsNoTracking() + .FirstOrDefaultAsync(i => i.ItemId == output.ItemId, ct) + ?? throw new DomainException(ErrorCodes.Validation, $"Item {output.ItemId} no longer exists.", 422); + + // docs/30 defines no batch/serial creation on receipt, so a tracked finished good has + // no valid path. Refuse explicitly rather than silently creating untracked stock. + if (item.TrackingMode != TrackingMode.None) + throw new DomainException(ErrorCodes.Validation, + $"Item {item.Sku} is {item.TrackingMode}-tracked; batch/serial-tracked finished goods " + + "are not supported in this phase.", 422); + + var qtyBase = await _uomConverter.ToBaseQtyAsync(item, output.UomId, good, ct); + + var consumedValue = run.Stages.SelectMany(s => s.Inputs).Sum(i => i.ConsumedValue); + var returnedValue = run.Stages.SelectMany(s => s.Inputs).Sum(i => i.ReturnedValue); + var pool = consumedValue - returnedValue; + + var unitCost = Math.Round(pool / qtyBase, 6, MidpointRounding.AwayFromZero); + + var layer = await _fifo.CreateInboundLayerAsync( + item.ItemId, run.WarehouseId, batchId: null, serialId: null, grnLineId: null, + qtyBase, unitCost, now, ct); + + var balance = await _fifo.GetOnHandAsync(item.ItemId, run.WarehouseId, ct) + qtyBase; + + // valueOverride carries the pool exactly. unitCost is rounded to 6 dp, so at 100+ + // units qty × unitCost drifts from the pool by more than the ledger's 4 dp tick and + // Σ ledger value would no longer reconcile to Σ consumed − Σ returned. + var ledgerValue = Math.Round(pool, 4, MidpointRounding.AwayFromZero); + var entry = await _fifo.PostLedgerAsync( + item.ItemId, run.WarehouseId, run.OutputBinId, batchId: null, serialId: null, + _currentUser.AuditUserId, Direction.In, qtyBase, unitCost, balance, + LedgerSourceTypes.ProductionReceipt, run.RunId, now, ct, valueOverride: ledgerValue); + + // StockLayer carries no bin, so outputBinId reaches the ledger only; echo the run's + // bin rather than reading it back off the layer. + var receipt = new Receipt( + layer, item.ItemId, run.WarehouseId, run.OutputBinId, qtyBase, unitCost, ledgerValue); + + return (receipt, new CostPoolDto(consumedValue, returnedValue, pool), entry); + } + + private static bool IsTerminal(ProductionRun run, RunStage stage) + => !run.Edges.Any(e => e.ParentRunStageId == stage.RunStageId); + + /// + /// Loads the run graph tracked and resolves the stage, enforcing that the run is still + /// open. Shared by every stage action so the guards can't diverge. + /// + private async Task<(ProductionRun Run, RunStage Stage)> LoadForActionAsync( + int runId, int runStageId, CancellationToken ct) + { + var run = await LoadGraphQuery().FirstOrDefaultAsync(r => r.RunId == runId, ct) + ?? throw new NotFoundException($"Production run {runId} was not found."); + + if (run.Status != ProductionRunStatus.InProgress) + throw new ConflictException($"Run {run.DocNo} is {run.Status}; no further stage actions are possible."); + + var stage = run.Stages.FirstOrDefault(s => s.RunStageId == runStageId) + ?? throw new NotFoundException($"Stage {runStageId} is not part of run {runId}."); + + return (run, stage); + } + + /// FR-MFG-07: every field marked required must carry a non-empty value. + private static void ValidateRequiredFields(RunStage stage, JsonElement? values) + { + var defs = ProductionJson.Deserialize>(stage.FieldDefs, []); + var required = defs.Where(d => d.Required).ToList(); + if (required.Count == 0) return; + + var missing = new List(); + foreach (var def in required) + { + if (values is null || values.Value.ValueKind != JsonValueKind.Object + || !values.Value.TryGetProperty(def.Key, out var value) + || value.ValueKind is JsonValueKind.Null or JsonValueKind.Undefined + || (value.ValueKind == JsonValueKind.String && string.IsNullOrWhiteSpace(value.GetString()))) + { + missing.Add(def.Label); + } + } + + if (missing.Count > 0) + throw new DomainException(ErrorCodes.RequiredFieldMissing, + $"Required field(s) not provided for stage '{stage.Name}': {string.Join(", ", missing)}.", 400); + } + + private async Task EnsureProductionReasonAsync(int reasonCodeId, CancellationToken ct) + { + var reason = await _reasonCodes.Query().AsNoTracking() + .FirstOrDefaultAsync(r => r.ReasonCodeId == reasonCodeId, ct) + ?? throw new DomainException(ErrorCodes.Validation, + $"Reason code {reasonCodeId} does not exist.", 422); + + if (reason.Context != ReasonContext.Production) + throw new DomainException(ErrorCodes.Validation, + $"Reason code '{reason.Code}' is a {reason.Context} reason, not a Production reason.", 422); + } + + private async Task RequireStageAsync(int runId, int runStageId, CancellationToken ct) + { + var run = await GetAsync(runId, ct) + ?? throw new NotFoundException($"Production run {runId} was not found."); + return run.Value.Stages.First(s => s.RunStageId == runStageId); + } + + // --- shared helpers ------------------------------------------------------ + + private IQueryable LoadGraphQuery() => + _runs.Query() + .Include(r => r.Template) + .Include(r => r.Stages).ThenInclude(s => s.Inputs) + .Include(r => r.Stages).ThenInclude(s => s.Outputs) + .Include(r => r.Edges) + .Include(r => r.Events); + + /// + /// Re-evaluates a single stage's Waiting/Ready state against its upstream deliveries + /// (FR-MFG-09 — an all-parents join, per-edge full delivery). + /// + /// + /// Only ever moves between Waiting and Ready; a started stage is left alone, so callers + /// can invoke it on any stage without guarding. A stage with no upstream inputs is an + /// entry stage and is always Ready. The comparison is >=, not ==, so a + /// partial-then-full transfer sequence still satisfies it. + /// + internal static void RecomputeReadiness(RunStage stage) + { + if (stage.Status is not (ProductionStageStatus.Waiting or ProductionStageStatus.Ready)) return; + + var upstream = stage.Inputs.Where(i => i.Source == StageInputSource.Upstream).ToList(); + var satisfied = upstream.Count == 0 || upstream.All(i => i.DeliveredQty >= i.PlannedQty); + + stage.Status = satisfied ? ProductionStageStatus.Ready : ProductionStageStatus.Waiting; + } + + private void AddEvent(ProductionRun run, RunStage? stage, RunStageEventType type, string? note, object? payload) + { + var ev = new RunStageEvent + { + Run = run, + RunStage = stage, + EventType = type, + Note = note, + Payload = payload is null ? null : ProductionJson.Serialize(payload), + UserId = _currentUser.AuditUserId, + CreatedAt = DateTime.UtcNow + }; + run.Events.Add(ev); + stage?.Events.Add(ev); + } + + // --- mapping ------------------------------------------------------------- + + private static RunGraphDto ToGraphDto(ProductionRun run) + { + var hasOutbound = run.Edges.Select(e => e.ParentRunStageId).ToHashSet(); + var hasInbound = run.Edges.Select(e => e.ChildRunStageId).ToHashSet(); + + var consumed = run.Stages.SelectMany(s => s.Inputs).Sum(i => i.ConsumedValue); + var returned = run.Stages.SelectMany(s => s.Inputs).Sum(i => i.ReturnedValue); + + var stages = run.Stages + .OrderBy(s => s.RunStageId) + .Select(s => new RunStageDto( + s.RunStageId, s.TemplateStageId, s.Name, s.RoleLabel, s.EstimatedMinutes, s.PosX, s.PosY, + s.Status, + !hasOutbound.Contains(s.RunStageId), + !hasInbound.Contains(s.RunStageId), + s.ActualStartAt, s.ActualEndAt, + s.ActualStartAt is not null && s.ActualEndAt is not null + ? (int)Math.Round((s.ActualEndAt.Value - s.ActualStartAt.Value).TotalMinutes) + : null, + ProductionJson.Deserialize>(s.FieldDefs, []), + ParseJson(s.FieldValues), + s.Inputs.OrderBy(i => i.RunInputId).Select(i => new RunStageInputDto( + i.RunInputId, i.Source, i.ItemId, i.FromRunOutputId, i.UomId, + i.PlannedQty, i.ConsumedQty, i.ConsumedValue, + i.DeliveredQty, i.ReturnedQty, i.ReturnedValue)).ToList(), + s.Outputs.OrderBy(o => o.RunOutputId).Select(o => new RunStageOutputDto( + o.RunOutputId, o.ItemId, o.Name, o.UomId, + o.PlannedQty, o.ProducedQty, o.ScrappedQty, o.ScrapReasonCodeId, + o.TransferredQty, + o.ProducedQty - o.ScrappedQty - o.TransferredQty)).ToList())) + .ToList(); + + var edges = run.Edges + .OrderBy(e => e.RunEdgeId) + .Select(e => new RunEdgeDto(e.RunEdgeId, e.ParentRunStageId, e.ChildRunStageId)) + .ToList(); + + var events = run.Events + .OrderBy(e => e.EventId) + .Select(e => new RunEventDto( + e.EventId, e.RunStageId, e.EventType, e.Note, ParseJson(e.Payload), e.UserId, e.CreatedAt)) + .ToList(); + + return new RunGraphDto( + run.RunId, run.DocNo, run.TemplateId, run.Template?.Name ?? string.Empty, + run.WarehouseId, run.OutputBinId, run.TargetQty, run.ScaleFactor, + run.Status, run.ReworkCount, run.CancelReasonCodeId, + new CostPoolDto(consumed, returned, consumed - returned), + stages, edges, events, + run.CreatedBy, run.CreatedAt, run.CompletedAt); + } + + private static JsonElement? ParseJson(string? json) + => string.IsNullOrWhiteSpace(json) ? null : JsonDocument.Parse(json).RootElement.Clone(); +} diff --git a/Backend/ERPCore/Services/Production/ProductionTemplateService.cs b/Backend/ERPCore/Services/Production/ProductionTemplateService.cs new file mode 100644 index 0000000..d63aaf6 --- /dev/null +++ b/Backend/ERPCore/Services/Production/ProductionTemplateService.cs @@ -0,0 +1,496 @@ +using ERPCore.Common.Http; +using ERPCore.Domain.Entities; +using ERPCore.Domain.Enums; +using ERPCore.Dtos.Common; +using ERPCore.Dtos.Production; +using ERPCore.Infra.Auth; +using ERPCore.Infra.UoW; +using ERPCore.Repositories.Interfaces; +using ERPCore.Services.Interfaces; +using ERPCore.System.Errors; +using Microsoft.EntityFrameworkCore; + +namespace ERPCore.Services.Production; + +/// +/// Production template CRUD + graph validation (docs/30 §D.1, FR-MFG-01..07). +/// Graph rules live in ; everything needing the +/// database (referential checks, the edit-lock, reconciliation) lives here. +/// +public sealed class ProductionTemplateService : IProductionTemplateService +{ + private readonly IRepository _templates; + private readonly IRepository _stages; + private readonly IRepository _inputs; + private readonly IRepository _outputs; + private readonly IRepository _edges; + private readonly IRepository _items; + private readonly IRepository _uoms; + private readonly IRepository _runs; + private readonly IUnitOfWork _uow; + private readonly ICurrentUser _currentUser; + + public ProductionTemplateService( + IRepository templates, IRepository stages, + IRepository inputs, IRepository outputs, IRepository edges, + IRepository items, IRepository uoms, IRepository runs, + IUnitOfWork uow, ICurrentUser currentUser) + { + _templates = templates; + _stages = stages; + _inputs = inputs; + _outputs = outputs; + _edges = edges; + _items = items; + _uoms = uoms; + _runs = runs; + _uow = uow; + _currentUser = currentUser; + } + + public async Task> ListAsync( + PageQuery query, EntityStatus? status, CancellationToken ct = default) + { + var q = _templates.Query().AsNoTracking(); + + if (!string.IsNullOrWhiteSpace(query.Q)) + { + var term = query.Q.Trim(); + q = q.Where(t => EF.Functions.ILike(t.Code, $"%{term}%") || EF.Functions.ILike(t.Name, $"%{term}%")); + } + + if (status is not null) q = q.Where(t => t.Status == status); + + var total = await q.CountAsync(ct); + + // Projected to an anonymous type first, then mapped client-side: EF Core 10 cannot + // translate a record constructor sitting alongside aggregates and a collection + // projection (same limitation recorded for WarehouseValuationDto, 2026-07-28). + var rows = await q + .OrderBy(t => t.Code) + .Skip(query.Skip).Take(query.PageSize) + .Select(t => new + { + t.TemplateId, + t.Code, + t.Name, + t.Status, + StageCount = t.Stages.Count, + Stages = t.Stages.Select(s => new { s.StageId, s.Name }).ToList(), + Edges = t.Edges.Select(e => new { e.ParentStageId, e.ChildStageId }).ToList(), + // Drives the canvas edit-lock banner (docs/21 §2) and mirrors the + // condition UpdateAsync enforces server-side. + ActiveRunCount = t.Runs.Count(r => r.Status == ProductionRunStatus.InProgress), + t.CreatedBy, + t.CreatedAt + }) + .ToListAsync(ct); + + var items = rows.Select(t => new TemplateSummaryDto( + t.TemplateId, t.Code, t.Name, t.Status, t.StageCount, + FlowOrderedNames( + t.Stages.Select(s => (s.StageId, s.Name)).ToList(), + t.Edges.Select(e => (e.ParentStageId, e.ChildStageId)).ToList()), + t.ActiveRunCount, t.CreatedBy, t.CreatedAt)).ToList(); + + return PagedResponse.Create(items, query.Page, query.PageSize, total); + } + + /// + /// Stage names in flow order — upstream first — for the overview canvas, which + /// draws each template as a line left to right (docs/21 §1). + /// + /// + /// Ordering by StageId would be insertion order, which routinely puts the terminal + /// stage first and renders the line backwards. Kahn's algorithm over the edge set gives the + /// real sequence, tie-broken by stage id so parallel branches come out deterministically. + /// Falls back to id order if the graph somehow contains a cycle, so a listing can never + /// fail because of bad data. + /// + private static List FlowOrderedNames( + List<(int StageId, string Name)> stages, List<(int ParentStageId, int ChildStageId)> edges) + { + var nameById = stages.ToDictionary(s => s.StageId, s => s.Name); + var children = stages.ToDictionary(s => s.StageId, _ => new List()); + var indegree = stages.ToDictionary(s => s.StageId, _ => 0); + + foreach (var (parent, child) in edges) + { + if (!children.ContainsKey(parent) || !indegree.ContainsKey(child)) continue; + children[parent].Add(child); + indegree[child]++; + } + + // SortedSet keeps the frontier in id order, so the output is stable run to run. + var frontier = new SortedSet(indegree.Where(kv => kv.Value == 0).Select(kv => kv.Key)); + var ordered = new List(stages.Count); + + while (frontier.Count > 0) + { + var next = frontier.Min; + frontier.Remove(next); + ordered.Add(nameById[next]); + + foreach (var child in children[next]) + if (--indegree[child] == 0) + frontier.Add(child); + } + + return ordered.Count == stages.Count + ? ordered + : stages.OrderBy(s => s.StageId).Select(s => s.Name).ToList(); + } + + public async Task?> GetAsync(int templateId, CancellationToken ct = default) + { + var template = await LoadGraphQuery().AsNoTracking() + .FirstOrDefaultAsync(t => t.TemplateId == templateId, ct); + + if (template is null) return null; + + // Counted separately rather than Included: the graph query already fans out over four + // collections, and adding Runs would multiply those rows again for a single integer. + var activeRuns = await _runs.Query().AsNoTracking() + .CountAsync(r => r.TemplateId == templateId && r.Status == ProductionRunStatus.InProgress, ct); + + return new ETagged(ToGraphDto(template, activeRuns), template.RowVersion); + } + + public async Task> CreateAsync(SaveTemplateRequest request, CancellationToken ct = default) + { + var code = request.Code.Trim(); + if (await _templates.Query().AnyAsync(t => t.Code == code, ct)) + throw new ConflictException($"A production template with code '{code}' already exists."); + + var template = new ProductionTemplate + { + Code = code, + Name = request.Name.Trim(), + Description = request.Description?.Trim(), + Status = EntityStatus.Active, + CreatedBy = _currentUser.AuditUserId, + CreatedAt = DateTime.UtcNow + }; + + await ValidateAsync(request, ct); + + await _uow.ExecuteInTransactionAsync(async token => + { + await _templates.AddAsync(template, token); + BuildGraph(template, request); + }, ct); + + return await RequireGraphAsync(template.TemplateId, ct); + } + + public async Task> UpdateAsync( + int templateId, SaveTemplateRequest request, uint expectedRowVersion, CancellationToken ct = default) + { + await ValidateAsync(request, ct); + + var code = request.Code.Trim(); + if (await _templates.Query().AnyAsync(t => t.Code == code && t.TemplateId != templateId, ct)) + throw new ConflictException($"A production template with code '{code}' already exists."); + + await _uow.ExecuteInTransactionAsync(async token => + { + var template = await LoadGraphQuery().FirstOrDefaultAsync(t => t.TemplateId == templateId, token) + ?? throw new NotFoundException($"Production template {templateId} was not found."); + + if (template.RowVersion != expectedRowVersion) + throw new DomainException(ErrorCodes.ConcurrencyConflict, + "The template was modified by another request.", 412); + + // FR-MFG-06: edit-lock instead of versioning. Checked inside the transaction to + // keep the window small; the residual race is benign because a run copies + // everything it needs at creation and never reads the template again. + var activeRuns = await _runs.Query().AsNoTracking() + .CountAsync(r => r.TemplateId == templateId && r.Status == ProductionRunStatus.InProgress, token); + if (activeRuns > 0) + throw new DomainException(ErrorCodes.TemplateInUse, + $"This template has {activeRuns} run(s) in progress and cannot be edited until they finish.", 409); + + template.Code = code; + template.Name = request.Name.Trim(); + template.Description = request.Description?.Trim(); + + // Two passes, deliberately. Tearing the old graph down and flushing before + // rebuilding removes any dependence on how EF happens to order a mixed batch of + // inserts and deletes — which matters because stage_inputs → stage_outputs is a + // Restrict FK and stage_edges carries a unique (parent, child) index. + var keptStages = TearDownGraph(template, request); + await _uow.SaveChangesAsync(token); + + BuildGraph(template, request, keptStages); + }, ct); + + return await RequireGraphAsync(templateId, ct); + } + + public async Task SetStatusAsync(int templateId, EntityStatus status, CancellationToken ct = default) + { + var template = await _templates.Query().FirstOrDefaultAsync(t => t.TemplateId == templateId, ct) + ?? throw new NotFoundException($"Production template {templateId} was not found."); + + template.Status = status; + await _uow.SaveChangesAsync(ct); + } + + // --- graph reconciliation ------------------------------------------------ + + private IQueryable LoadGraphQuery() => + _templates.Query() + .Include(t => t.Stages).ThenInclude(s => s.Inputs) + .Include(t => t.Stages).ThenInclude(s => s.Outputs) + .Include(t => t.Edges); + + /// + /// Runs the pure graph rules then the referential ones. Item/UOM existence needs the + /// database, so it can't live in the validator — but it has to run before any write. + /// + private async Task ValidateAsync(SaveTemplateRequest request, CancellationToken ct) + { + ProductionGraphValidator.Validate( + request.Stages.Select(s => new ProductionGraphValidator.StageDraft( + s.Key, s.Name, + s.Inputs.Select((i, idx) => new ProductionGraphValidator.InputDraft(idx, i.Source, i.ItemId, i.FromOutputKey)).ToList(), + s.Outputs.Select(o => new ProductionGraphValidator.OutputDraft(o.Key, o.Name, o.ItemId)).ToList())).ToList(), + request.Edges.Select(e => new ProductionGraphValidator.EdgeDraft(e.ParentKey, e.ChildKey)).ToList()); + + var itemIds = request.Stages + .SelectMany(s => s.Inputs.Select(i => i.ItemId).Concat(s.Outputs.Select(o => o.ItemId))) + .OfType().Distinct().ToList(); + + if (itemIds.Count > 0) + { + var found = await _items.Query().AsNoTracking() + .Where(i => itemIds.Contains(i.ItemId)) + .Select(i => new { i.ItemId, i.Status }) + .ToListAsync(ct); + + var missing = itemIds.Except(found.Select(f => f.ItemId)).ToList(); + if (missing.Count > 0) + throw new DomainException(ErrorCodes.Validation, + $"Item(s) {string.Join(", ", missing)} do not exist.", 422); + + var inactive = found.Where(f => f.Status != EntityStatus.Active).Select(f => f.ItemId).ToList(); + if (inactive.Count > 0) + throw new DomainException(ErrorCodes.Validation, + $"Item(s) {string.Join(", ", inactive)} are inactive and cannot be used in a template.", 422); + } + + var uomIds = request.Stages + .SelectMany(s => s.Inputs.Select(i => i.UomId).Concat(s.Outputs.Select(o => o.UomId))) + .Distinct().ToList(); + + var knownUoms = await _uoms.Query().AsNoTracking() + .Where(u => uomIds.Contains(u.UomId)).Select(u => u.UomId).ToListAsync(ct); + + var missingUoms = uomIds.Except(knownUoms).ToList(); + if (missingUoms.Count > 0) + throw new DomainException(ErrorCodes.Validation, + $"UOM(s) {string.Join(", ", missingUoms)} do not exist.", 422); + + // Annotations go into jsonb unvalidated by anything else, so pin the one field the + // client renders off. Unknown kinds would round-trip fine but draw nothing. + var badKinds = request.Annotations + .Select(a => a.Kind) + .Where(k => k is not ("box" or "line")) + .Distinct().ToList(); + if (badKinds.Count > 0) + throw new DomainException(ErrorCodes.Validation, + $"Unknown canvas annotation kind(s): {string.Join(", ", badKinds)}. Expected 'box' or 'line'.", 422); + } + + /// + /// Removes everything the incoming payload replaces and returns the surviving stages + /// by key. + /// + /// + /// Inputs and outputs are always replaced wholesale — nothing outside the template + /// references them, because a run copies into its own run_stage_input/ + /// run_stage_output rows. Stages are diffed, not replaced, because + /// run_stages.TemplateStageId points at them; a stage that disappears from the + /// payload is deleted and that FK is set null for any historical run (see + /// RunStageConfiguration). + /// + private Dictionary TearDownGraph(ProductionTemplate template, SaveTemplateRequest request) + { + var payloadKeys = request.Stages.Select(s => s.Key).ToHashSet(StringComparer.Ordinal); + + foreach (var stage in template.Stages) + { + foreach (var input in stage.Inputs.ToList()) _inputs.Remove(input); + foreach (var output in stage.Outputs.ToList()) _outputs.Remove(output); + } + + var kept = new Dictionary(StringComparer.Ordinal); + var doomed = new List(); + foreach (var stage in template.Stages.ToList()) + { + var key = stage.StageId.ToString(); + if (payloadKeys.Contains(key)) kept[key] = stage; + else doomed.Add(stage); + } + + // Edges are diffed rather than replaced: stage_edges has a unique (parent, child) + // index, and dropping then re-adding an unchanged edge in the same round trip can + // trip it depending on statement order. + var wanted = request.Edges + .Select(e => (Parent: ResolveKeptId(kept, e.ParentKey), Child: ResolveKeptId(kept, e.ChildKey))) + .Where(e => e.Parent is not null && e.Child is not null) + .Select(e => (e.Parent!.Value, e.Child!.Value)) + .ToHashSet(); + + // Edges must go before stages. StageEdge.ParentStage/ChildStage are required + // relationships, so deleting a stage that a still-live edge points at makes EF throw + // "the association ... has been severed". Any edge touching a doomed stage is + // necessarily absent from `wanted` — the payload cannot reference a stage it dropped + // — so this ordering never orphans an edge the caller wanted to keep. + foreach (var edge in template.Edges.ToList()) + if (!wanted.Contains((edge.ParentStageId, edge.ChildStageId))) + _edges.Remove(edge); + + foreach (var stage in doomed) + _stages.Remove(stage); + + return kept; + } + + private static int? ResolveKeptId(Dictionary kept, string key) + => kept.TryGetValue(key, out var stage) ? stage.StageId : null; + + /// + /// Materialises the payload onto the template. + /// + /// + /// Everything is wired through navigation properties rather than foreign-key + /// ints, so EF resolves the ids itself during a single SaveChanges. That is what + /// lets a brand-new Upstream input point at a brand-new output without an intermediate + /// save to materialise generated keys — outputs are built in the first pass precisely + /// so the second pass has the entity instances to hand. + /// + private void BuildGraph( + ProductionTemplate template, SaveTemplateRequest request, + Dictionary? keptStages = null) + { + // Replaced wholesale — annotations are opaque client state, not part of the graph, so + // there is nothing to diff and nothing else can reference them. + template.Annotations = request.Annotations.Count == 0 + ? null + : ProductionJson.Serialize(request.Annotations); + + var stagesByKey = new Dictionary(StringComparer.Ordinal); + var outputsByKey = new Dictionary(StringComparer.Ordinal); + + // Pass 1 — stages and their outputs. + foreach (var s in request.Stages) + { + if (keptStages is null || !keptStages.TryGetValue(s.Key, out var stage)) + { + stage = new TemplateStage { Template = template }; + template.Stages.Add(stage); + } + + stage.Name = s.Name.Trim(); + stage.RoleLabel = string.IsNullOrWhiteSpace(s.RoleLabel) ? null : s.RoleLabel.Trim(); + stage.EstimatedMinutes = s.EstimatedMinutes; + stage.PosX = s.PosX; + stage.PosY = s.PosY; + stage.FieldDefs = ProductionJson.Serialize(s.FieldDefs); + + stagesByKey[s.Key] = stage; + + foreach (var o in s.Outputs) + { + var output = new StageOutput + { + Stage = stage, + ItemId = o.ItemId, + Name = o.Name.Trim(), + UomId = o.UomId, + QtyPerBatch = o.QtyPerBatch + }; + stage.Outputs.Add(output); + outputsByKey[o.Key] = output; + } + } + + // Pass 2 — inputs, which may reference any output built above. + foreach (var s in request.Stages) + { + var stage = stagesByKey[s.Key]; + foreach (var i in s.Inputs) + { + stage.Inputs.Add(new StageInput + { + Stage = stage, + Source = i.Source, + ItemId = i.Source == StageInputSource.Stock ? i.ItemId : null, + FromOutput = i.Source == StageInputSource.Upstream ? outputsByKey[i.FromOutputKey!] : null, + UomId = i.UomId, + QtyPerBatch = i.QtyPerBatch + }); + } + } + + // Pass 3 — edges not already present. + var existing = template.Edges + .Select(e => (e.ParentStageId, e.ChildStageId)).ToHashSet(); + + foreach (var e in request.Edges) + { + var parent = stagesByKey[e.ParentKey]; + var child = stagesByKey[e.ChildKey]; + if (parent.StageId != 0 && child.StageId != 0 && existing.Contains((parent.StageId, child.StageId))) + continue; + + template.Edges.Add(new StageEdge + { + Template = template, + ParentStage = parent, + ChildStage = child + }); + } + } + + // --- mapping ------------------------------------------------------------- + + private async Task> RequireGraphAsync(int templateId, CancellationToken ct) + => await GetAsync(templateId, ct) + ?? throw new NotFoundException($"Production template {templateId} was not found."); + + private static TemplateGraphDto ToGraphDto(ProductionTemplate t, int activeRunCount) + { + // The key a client sends back is just the id as a string; computing it here keeps + // that contract in exactly one place. + var outputKeyById = t.Stages + .SelectMany(s => s.Outputs) + .ToDictionary(o => o.OutputId, o => o.OutputId.ToString()); + + var stages = t.Stages + .OrderBy(s => s.StageId) + .Select(s => new TemplateStageDto( + s.StageId, s.StageId.ToString(), s.Name, s.RoleLabel, s.EstimatedMinutes, s.PosX, s.PosY, + ProductionJson.Deserialize>(s.FieldDefs, []), + s.Inputs.OrderBy(i => i.InputId).Select(i => new StageInputDto( + i.InputId, i.Source, i.ItemId, i.FromOutputId, + i.FromOutputId is null ? null : outputKeyById.GetValueOrDefault(i.FromOutputId.Value), + i.UomId, i.QtyPerBatch)).ToList(), + s.Outputs.OrderBy(o => o.OutputId).Select(o => new StageOutputDto( + o.OutputId, o.OutputId.ToString(), o.ItemId, o.Name, o.UomId, o.QtyPerBatch)).ToList())) + .ToList(); + + var edges = t.Edges + .OrderBy(e => e.EdgeId) + .Select(e => new TemplateEdgeDto( + e.EdgeId, e.ParentStageId, e.ChildStageId, + e.ParentStageId.ToString(), e.ChildStageId.ToString())) + .ToList(); + + return new TemplateGraphDto( + t.TemplateId, t.Code, t.Name, t.Description, t.Status, stages, edges, + ProductionJson.Deserialize>(t.Annotations, []), + activeRunCount, t.CreatedBy, t.CreatedAt); + } +} diff --git a/Backend/ERPCore/Services/Stock/FifoCostingService.cs b/Backend/ERPCore/Services/Stock/FifoCostingService.cs index 5deadbc..c2f5d23 100644 --- a/Backend/ERPCore/Services/Stock/FifoCostingService.cs +++ b/Backend/ERPCore/Services/Stock/FifoCostingService.cs @@ -121,7 +121,8 @@ public sealed class FifoCostingService : IFifoCostingService public async Task PostLedgerAsync( int itemId, int warehouseId, int? binId, int? batchId, int? serialId, int userId, Direction direction, decimal qtyBase, decimal unitCost, decimal runningBalance, - string sourceDocType, int sourceDocId, DateTime createdAt, CancellationToken ct = default) + string sourceDocType, int sourceDocId, DateTime createdAt, CancellationToken ct = default, + decimal? valueOverride = null) { var entry = new StockLedger { @@ -134,7 +135,9 @@ public sealed class FifoCostingService : IFifoCostingService Direction = direction, QtyBase = qtyBase, UnitCost = unitCost, - Value = Math.Round(qtyBase * unitCost, 4, MidpointRounding.AwayFromZero), + Value = valueOverride is not null + ? Math.Round(valueOverride.Value, 4, MidpointRounding.AwayFromZero) + : Math.Round(qtyBase * unitCost, 4, MidpointRounding.AwayFromZero), RunningBalance = runningBalance, SourceDocType = sourceDocType, SourceDocId = sourceDocId, diff --git a/Backend/ERPCore/Services/Stock/UomConverter.cs b/Backend/ERPCore/Services/Stock/UomConverter.cs new file mode 100644 index 0000000..c9fcacc --- /dev/null +++ b/Backend/ERPCore/Services/Stock/UomConverter.cs @@ -0,0 +1,38 @@ +using ERPCore.Domain.Entities; +using ERPCore.Repositories.Interfaces; +using ERPCore.Services.Interfaces; +using ERPCore.System.Errors; +using Microsoft.EntityFrameworkCore; + +namespace ERPCore.Services.Stock; + +/// +/// Shared UOM → base-UOM conversion (see ). Behaviour is +/// unchanged from the GrnService.ToBaseAsync it was extracted from, so the GRN +/// receive path keeps costing exactly as before. +/// +public sealed class UomConverter : IUomConverter +{ + private readonly IRepository _conversions; + + public UomConverter(IRepository conversions) => _conversions = conversions; + + public async Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync( + Item item, int uomId, decimal qty, decimal unitCostPerUom, CancellationToken ct = default) + { + if (uomId == item.BaseUomId) + return (qty, unitCostPerUom); + + var conv = await _conversions.Query().AsNoTracking() + .FirstOrDefaultAsync(c => c.ItemId == item.ItemId && c.FromUomId == uomId && c.ToUomId == item.BaseUomId, ct) + ?? throw new DomainException(ErrorCodes.Validation, + $"No UOM conversion from {uomId} to base UOM {item.BaseUomId} for item {item.ItemId}.", 422); + + // Quantity scales up by the factor, so the per-unit cost scales down by it — + // total value is preserved. + return (qty * conv.Factor, unitCostPerUom / conv.Factor); + } + + public async Task ToBaseQtyAsync(Item item, int uomId, decimal qty, CancellationToken ct = default) + => (await ToBaseAsync(item, uomId, qty, 0m, ct)).QtyBase; +} diff --git a/Backend/ERPCore/System/Errors/ErrorCodes.cs b/Backend/ERPCore/System/Errors/ErrorCodes.cs index ee5dd78..903af82 100644 --- a/Backend/ERPCore/System/Errors/ErrorCodes.cs +++ b/Backend/ERPCore/System/Errors/ErrorCodes.cs @@ -47,4 +47,23 @@ public static class ErrorCodes public const string SalaryStructureOverlap = "SALARY_STRUCTURE_OVERLAP"; public const string TaxSlabGapInvalid = "TAX_SLAB_GAP_INVALID"; public const string PayrollPeriodLocked = "PAYROLL_PERIOD_LOCKED"; + + // Manufacturing / Production Lines (docs/30-BACKEND-PHASE2.md §D.4) + public const string TemplateInUse = "TEMPLATE_IN_USE"; + public const string TemplateInactive = "TEMPLATE_INACTIVE"; + public const string GraphCycle = "GRAPH_CYCLE"; + public const string GraphTerminalCount = "GRAPH_TERMINAL_COUNT"; + public const string GraphDisconnected = "GRAPH_DISCONNECTED"; + public const string GraphInputSourceInvalid = "GRAPH_INPUT_SOURCE_INVALID"; + public const string TerminalOutputItemRequired = "TERMINAL_OUTPUT_ITEM_REQUIRED"; + public const string StageNotReady = "STAGE_NOT_READY"; + public const string StageNotInProgress = "STAGE_NOT_IN_PROGRESS"; + public const string StageNotDone = "STAGE_NOT_DONE"; + public const string StageNotEditable = "STAGE_NOT_EDITABLE"; + public const string StageRejectInvalid = "STAGE_REJECT_INVALID"; + public const string RequiredFieldMissing = "REQUIRED_FIELD_MISSING"; + public const string TransferExceedsAvailable = "TRANSFER_EXCEEDS_AVAILABLE"; + public const string LeftoverExceedsConsumed = "LEFTOVER_EXCEEDS_CONSUMED"; + public const string RunCostClosed = "RUN_COST_CLOSED"; + public const string RunNotCancellable = "RUN_NOT_CANCELLABLE"; } diff --git a/Backend/ERPCore/appsettings.json b/Backend/ERPCore/appsettings.json index e207a35..ee6e372 100644 --- a/Backend/ERPCore/appsettings.json +++ b/Backend/ERPCore/appsettings.json @@ -16,7 +16,7 @@ "RequiredRoleCode": "" }, "AuthHex": { - "BaseUrl": "http://localhost:5011" + "BaseUrl": "http://localhost:5602" }, "FileStorage": { "RootPath": "App_Data/hr-documents", diff --git a/Backend/PROGRESS.md b/Backend/PROGRESS.md index 49b419b..f9431cf 100644 --- a/Backend/PROGRESS.md +++ b/Backend/PROGRESS.md @@ -178,6 +178,98 @@ Spec: `docs/12-BACKEND-HRM.md` (model + rules) · `docs/13-BACKEND-HRM-API.md` ( - [x] Employee salary history (`.../salary-history?employeeId=`) — full `EmployeeSalaryStructure` revision history, ordered newest first - [x] Leave balance report (`.../leave-balances?year=`), document expiry report (`.../document-expiry?withinDays=`) +--- + +# Manufacturing — Production Lines (Phase 2) + +Spec: `docs/30-BACKEND-PHASE2.md` (model + rules **and** API — one doc, unlike Phase 1). Frontend consumption: `docs/21-FRONTEND-PHASE2.md`. Security: `docs/02-SECURITY.md §B.6` (narrow DTOs — statuses are never client-settable) + `§B.7` (FIFO row-locking inside the UoW txn). + +> **§11–§16 code complete, migration applied, and live smoke-tested (2026-07-30).** `dotnet build` clean (0 errors; the only warnings are the two pre-existing `CS8981` from the badly-named `chages` migration). Migration `AddManufacturingPhase2` — 11 `CreateTable`, zero `AlterColumn`, applied and verified against `information_schema`. **312 smoke assertions, all green**, via re-runnable scripts in `Backend/smoke/` against local Postgres + a real AuthHex session. + +## 11. Sub-phase 2.1 — Schema + enums +- [x] 11 entities (`ProductionTemplate`, `TemplateStage`, `StageEdge`, `StageInput`, `StageOutput`, `ProductionRun`, `RunStage`, `RunEdge`, `RunStageInput`, `RunStageOutput`, `RunStageEvent`) + `ProductionConfiguration.cs` (all 11 configs in one file, per the `StockConfiguration.cs` precedent). snake_case tables, PascalCase columns, enums as `varchar(20)`, qty/value `(18,4)`, unit cost + scale factor `(18,6)`, `xmin` RowVersion on template/run/run-stage +- [x] Enums `ProductionRunStatus`, `ProductionStageStatus`, `StageInputSource`, `RunStageEventType`, `CustomFieldType`; `ReasonContext` += `Production`; `DocumentTypes.Production = "PRD"`; new `Domain/LedgerSourceTypes.cs` +- [x] 4 Production reason codes seeded idempotently (`PRD-SCRAP`, `PRD-LEFTOVER`, `PRD-CANCEL`, `PRD-REWORK-LOSS`) — verified live via `GET /reason-codes?context=Production` +- [x] jsonb (`field_defs`, `field_values`, `payload`) as CLR `string` + `HasColumnType("jsonb")`, always written through `ProductionJson` so a column can only hold canonical JSON. Follows the `AuditLog.ChangeSet` precedent; a typed/owned mapping would make `AuditScribe` emit spurious audit rows for the nested entries + +## 12. Sub-phase 2.2 — Templates + graph validation (FR-MFG-01..07) +> **Smoke: 38/38** (`Backend/smoke/m2_templates.py`). Zero stock touched. +- [x] `ProductionGraphValidator` — a `public static class`, deliberately not an injected service (pure, synchronous, no DI). Kahn toposort → `GRAPH_CYCLE`; terminal count → `GRAPH_TERMINAL_COUNT`; one combined bidirectional-reachability check → `GRAPH_DISCONNECTED`; direct-parent check → `GRAPH_INPUT_SOURCE_INVALID`; terminal output → `TERMINAL_OUTPUT_ITEM_REQUIRED`. Works in **keys**, not ids, so identical code serves POST and PUT +- [x] `/production-templates` list/get/create/update/status, ETag + `If-Match` (428 missing, 412 stale), `409 TEMPLATE_IN_USE` on PUT while a run is InProgress +- [x] Full-graph PUT reconciliation: stages **diffed** (a run references them), inputs/outputs **replaced**, edges **diffed** (unique `(parent, child)` index). Rebuilt through navigation properties so EF resolves generated keys in one `SaveChanges` + +## 13. Sub-phase 2.3 — Run creation, board, detail, quantities (FR-MFG-08/09/18) +> **Smoke: 54/54** (`m3_runs.py`). Zero stock touched. +- [x] `POST /production-runs` — copies stages/inputs/outputs/edges in three passes, scales from the **unrounded** ratio (rounding each quantity once, so a repeating scale factor doesn't compound), `PRD-2026-0000N` from `NumberSequenceService` inside the transaction, entry stages `Ready` +- [x] `GET /production-runs` with `stageSummary` computed server-side; projected to an anonymous type first then mapped client-side (EF Core 10 cannot translate a record ctor alongside aggregates — same failure as `WarehouseValuationDto`, 2026-07-28) +- [x] `GET /production-runs/{id}` full graph incl. events, derived `isTerminal`/`isEntry`/`availableToTransfer`/`actualMinutes`/`costPool` +- [x] `PUT .../stages/{sid}/quantities` — `409 STAGE_NOT_EDITABLE` once started, and re-evaluates readiness (raising an upstream planned qty demotes a Ready stage back to Waiting) + +## 14. Sub-phase 2.4 — Stage execution (FR-MFG-10/11/12) · first stock-touching +> **Smoke: 66/66** (`m4_stage_actions.py`) **+ 14/14** (`m4b_uom_conversion.py`). Isolated `SMOKE-PRD` warehouse. +- [x] `…/start` — FIFO-consumes Stock inputs via `IFifoCostingService.ConsumeAsync`, `PRDI` ledger, `actualStartAt`. Consumes `max(0, plannedBase − consumedQty)` so a rework restart draws only the delta +- [x] `…/complete` — produced/scrapped per output + custom field values; `400 REQUIRED_FIELD_MISSING`, `400 REASON_CODE_REQUIRED`, Production-context reason enforced. **Overwrites** on a re-complete +- [x] `…/approve` (non-terminal) + `…/transfer` — default full transfer, optional partial, `422 TRANSFER_EXCEEDS_AVAILABLE`, child readiness recomputed. Routes by `fromRunOutputId`, not by edge +- [x] **`IUomConverter` extracted** from `GrnService.ToBaseAsync` into `Services/Stock/UomConverter.cs`; `GrnService` delegates to it, behaviour unchanged. Verified: a stage input declared in a 12× UOM consumes **360** base units, not 30; the ledger records base; an undefined conversion is `422`, never assumed 1:1 + +## 15. Sub-phase 2.5 — Terminal receipt + cost pool (FR-MFG-13) +> **Smoke: 36/36** (`m5_receipt.py`). +- [x] Terminal approve creates the finished layer at `costPool / goodQty`, posts `PRDR`, completes the run and closes the pool (`409 RUN_COST_CLOSED`) +- [x] **`decimal? valueOverride` added to `IFifoCostingService.PostLedgerAsync`** (default keeps `round(qty × unitCost, 4)`; every existing call site unaffected). Empirically necessary, not theoretical: at 300 units the 6 dp unit cost gives a naive value of `3405.5553` against a pool of `3405.5552` — a real 0.0001 drift. The smoke test asserts the naive product *would* have drifted, so the fixture cannot silently go blind +- [x] Batch/serial-tracked finished goods refused with `422` (this phase defines no batch creation on receipt). **Untested** — no tracked item exists in the dev DB; noted in the script + +## 16. Sub-phase 2.6 — Leftover return, rework, cancel (FR-MFG-14..17) +> **Smoke: 104/104** (`m6_m7_leftover_rework_cancel.py`). +- [x] `…/return-leftover` — inbound at the input's consumed weighted cost, `PRDL`, bin null (raw material, not the finished-goods bin). Value computed from the **unrounded** weighted cost and rounded once; a *full* return takes the exact residual so `returnedValue == consumedValue` precisely. `422 LEFTOVER_EXCEEDS_CONSUMED`, `409 RUN_COST_CLOSED` +- [x] `…/reject-intake` — parent `transferredQty` **decremented** (not zeroed, so a parent that also fed another child stays consistent), parent `Approved → InProgress` with `ActualStartAt` preserved, rejecting stage → `Waiting`. Allowed from `Ready` **or** `Waiting` with delivered intake +- [x] `…/reject` (terminal) — whole-run reset with one snapshot event per pass; `plannedQty` and `consumed*`/`returned*` **preserved**, stock untouched. Verified across two consecutive rework passes +- [x] `POST .../cancel` — returns `consumed − returned` per input at the consumed weighted cost (`PRDC`), `balances` dictionary accumulated per item (layers created in-transaction are invisible to `GetOnHandAsync` until `SaveChanges`), scrapped output qty recorded as `scrappedWrittenOff`. `409 RUN_NOT_CANCELLABLE` +- [x] Event history + estimated-vs-actual (FR-MFG-19) — every action writes one `RUN_STAGE_EVENT`; failed actions write none (the write rolls back with the change) + +**Bugs found and fixed during this phase (not silently patched):** +- **Template PUT 500** — deleting a `TemplateStage` while a `StageEdge` still referenced it severed a required EF relationship. Edges are now removed before stages; any edge touching a deleted stage is by construction absent from the payload, so nothing the caller wanted is orphaned. +- **`receipt.layerId` returned 0** — the `ReceiptDto` was built inside the transaction, before `SaveChanges` generated the id. Now mapped after the commit (same fix as the `ledgerRefs:[0]` issue recorded 2026-07-13). +- **Runtime messages carried U+2212** (typographic minus) and broke console/log encoding on Windows cp1252. Exception strings now use ASCII hyphens; comments keep the typographic form, matching the rest of the codebase. + +**Deviations / decisions (recorded, not silently assumed) — all mirrored into `docs/30`:** +- **§A.1 was a no-op.** `StockLayer.GrnLineId` was already nullable in entity, config, snapshot **and** database. Phase-1 schema was not altered at all; NFR-08 holds without exception. +- **Ledger codes are `PRDI`/`PRDR`/`PRDL`/`PRDC`**, not the doc's 15–22-char names — `SourceDocType` is `varchar(10)` on both `stock_ledger` and `journal_entry_stubs`, and widening it would have been a second Phase-1 schema change. +- **Three additions to Part C:** `RUN_EDGE` (a run must own its edges or a later template edit rewrites completed-run history), `RUN_STAGE.pos_x/pos_y` (the run canvas renders from them), `RUN_STAGE_EVENT.run_id` + nullable `run_stage_id` (run-level events, single-query timeline). `RUN_STAGE.template_stage_id` made nullable + `SET NULL` so a template stays editable after runs complete. +- **UOM conversion is unspecified in docs/30** but essential. Contract consequence: `plannedQty` is in the input's declared UOM while `consumed*`/`returned*` are in the item's **base** UOM. +- **`Idempotency-Key` accepted and ignored**, matching `GrnService.ConfirmAsync`. Status guards are the replay story; `RunStage.RowVersion` (xmin) prevents two concurrent terminal approves double-posting a receipt. +- **FR-MFG-17's "− scrapped" is not computable** at the input level (scrap lives on outputs, in output UOM). Scrap never entered stock, so nothing is deducted; scrapped quantities are recorded on the cancel event instead. +- **`GRAPH_DISCONNECTED` is unreachable** once cycle + terminal-count pass; kept as defence in depth. An isolated stage surfaces as `GRAPH_TERMINAL_COUNT`. +- **Edit-lock TOCTOU accepted** — checked inside the transaction, but under READ COMMITTED a run could still be created against a template mid-edit. Benign: runs copy everything at creation and never re-read the template. + +**Not done this pass (tracked, not silently skipped):** +- [x] **Frontend wiring** (`docs/21-FRONTEND-PHASE2.md` §8) — done in the same session; see `Frontend/PROGRESS.md` §§11–13. Not browser-verified (same AuthHex blocker). +- **Batch/serial-tracked finished goods** — guarded with a 422, and that guard is unexercised (no tracked item in the dev DB). +- **`NAV:production` permission** is not seeded; the sidebar still relies on the `bypassCodes` stopgap (same as `procurement`/`hrm`). +- **No automated test project** — verification is the `Backend/smoke/` scripts, per house practice. + +> ### 2026-07-30 — Dev-database repair + a drift audit worth repeating +> **`users."Email"` was missing from the database** while present in the entity and the model snapshot, so `ShadowUserClaimsTransformation`'s JIT insert failed with `42703` on **every authenticated request** — surfacing to callers as a confusing `InvalidOperationException: Sequence contains no elements`. `GET /items` and everything else 500'd. Fixed by the hand-written migration `RepairUserEmailColumn` (idempotent `ADD COLUMN IF NOT EXISTS` + the unique index, matching `UserConfiguration`'s `HasMaxLength(320)`). +> +> **Root cause — four migrations recorded as applied with zero operations:** `ini2`, `initial2`, `chages`, `chages1` each advanced the model snapshot without emitting any DDL. Anything added to the model in those windows exists in the snapshot but never reached the database. +> +> **Method note (this is the reusable part):** a scaffolded probe migration coming back **empty proves only `model == snapshot`, never `snapshot == database`** — which is exactly how this hid. The real audit was `dotnet ef dbcontext script` (which renders the *current model*) diffed against `information_schema.columns`. +> +> **Still outstanding — not fixed here, deliberately:** the same four empty migrations mean **all 25 HRM tables (`hr_*`) exist in the model and snapshot but not in this database**, so every HRM endpoint fails. Creating 25 tables of another module as a side effect of manufacturing work would be worse than reporting it; it needs its own repair migration and its own verification. +> +> **Also worth knowing:** `.gitignore:38` is `**/Migrations/`, so **no migration in this repo is version-controlled** — `AddManufacturingPhase2` and `RepairUserEmailColumn` exist only on the machine that created them. Anyone else must regenerate them. + +> ### 2026-07-30 (later) — Three server-side additions the frontend wiring needed +> All three are amended into `docs/30` as built. None changes an existing endpoint's behaviour. +> +> - **`TemplateGraphDto.activeRunCount`** — the builder derives its edit-locked state from it. Counted with its own scalar query rather than an `Include`, because the graph query already fans out over four collections and adding `Runs` would multiply those rows again for one integer. +> - **`production_templates."Annotations"` (jsonb)** + `SaveTemplateRequest.Annotations`, migration **`AddTemplateCanvasAnnotations`** (exactly one `AddColumn`, applied and verified). The builder canvas already drew grouping boxes and divider lines and the contract had nowhere to keep them, so **every save would have silently discarded the user's layout**. Stored through `ProductionJson` like every other jsonb column, so the column can only ever hold canonical JSON; `List` capped at 200 by `[MaxLength]`, and `Kind` validated to `box`/`line` in `ValidateAsync` because nothing else constrains free-form client state going into jsonb. Deliberately invisible to `ProductionGraphValidator` — annotations carry no graph semantics. +> - **Wholesale replacement is the flip side and is now pinned by an assertion:** a PUT that omits `annotations` clears them. `m2_templates.py` asserts preserve → clear → restore explicitly, because silent data loss is worse than an error. +> +> **Smoke suite: extended but NOT re-run.** `m2_templates.py` gained 10 assertions (annotation round-trip incl. geometry/label/rotation, `activeRunCount` on the graph, unknown-kind rejection, and the clear/restore pair). **These are unverified.** AuthHex cannot issue a token — its configured MySQL host `187.127.102.190:3306` is unreachable from this machine (`MySqlConnector … Connect Timeout expired` on `POST /api/user`), and the localhost alternative in its `appsettings.json` is commented out. `dotnet build` is clean and the migration applied cleanly, but the last full green run of the suite (312/312) predates these additions. +> +> **HRM schema gap CLOSED** (by the repo owner, not this work): migrations `production` (another empty one — the fifth) and **`AddHrmTables`** now exist, the latter creating all 25 `hr_*` tables. The "still outstanding" note in the entry above is resolved; the underlying lesson about empty migrations is not. + + ## Done diff --git a/Backend/smoke/__pycache__/smoke_common.cpython-313.pyc b/Backend/smoke/__pycache__/smoke_common.cpython-313.pyc new file mode 100644 index 0000000..6a93b70 Binary files /dev/null and b/Backend/smoke/__pycache__/smoke_common.cpython-313.pyc differ diff --git a/Backend/smoke/m2_templates.py b/Backend/smoke/m2_templates.py new file mode 100644 index 0000000..54aaa7e --- /dev/null +++ b/Backend/smoke/m2_templates.py @@ -0,0 +1,351 @@ +"""M2 smoke test — production template CRUD + graph validation (docs/30 §D.1, FR-MFG-01..07). + +Touches no stock: templates only. Run with the API and AuthHex up: + + python Backend/smoke/m2_templates.py + +Shape under test is a diamond, which exercises multiple entries converging on one +terminal *and* a stage with two parents: + + Cut ─┐ + ├─▶ Assemble (terminal, real item) + Prep ─┘ +""" + +from __future__ import annotations + +import sys + +from smoke_common import bootstrap + +TEMPLATE_CODE = "SMOKE-PT-M2" + + +def pick_fixtures(c, chk): + """Grab two active items and a UOM to build a realistic template from.""" + items = c.get("/items?pageSize=5&status=Active").body["items"] + if len(items) < 2: + sys.exit("FATAL: need at least 2 active items in the database.") + uoms = c.get("/uoms?pageSize=5").body["items"] + if not uoms: + sys.exit("FATAL: need at least 1 UOM in the database.") + return items[0]["itemId"], items[1]["itemId"], uoms[0]["uomId"] + + +def diamond(raw_item, finished_item, uom): + """A valid graph: two entry stages feeding one terminal stage.""" + return { + "code": TEMPLATE_CODE, + "name": "Smoke chair line", + "description": "Created by m2_templates.py", + "stages": [ + { + "key": "tmp-cut", "name": "Cut frame", "roleLabel": "Carpentry", + "estimatedMinutes": 60, "posX": 80, "posY": 120, + "fieldDefs": [{"key": "moisture_ok", "label": "Moisture check", + "type": "Checkbox", "required": True}], + "inputs": [{"source": "Stock", "itemId": raw_item, "uomId": uom, "qtyPerBatch": 8}], + "outputs": [{"key": "tmp-frame", "name": "Frame set", "uomId": uom, "qtyPerBatch": 1}], + }, + { + "key": "tmp-prep", "name": "Prep cushions", "roleLabel": "Upholstery", + "estimatedMinutes": 30, "posX": 80, "posY": 320, "fieldDefs": [], + "inputs": [{"source": "Stock", "itemId": raw_item, "uomId": uom, "qtyPerBatch": 2}], + "outputs": [{"key": "tmp-cushion", "name": "Cushion set", "uomId": uom, "qtyPerBatch": 1}], + }, + { + "key": "tmp-asm", "name": "Assemble & QA", "roleLabel": "QA", + "estimatedMinutes": 45, "posX": 560, "posY": 200, "fieldDefs": [], + "inputs": [ + {"source": "Upstream", "fromOutputKey": "tmp-frame", "uomId": uom, "qtyPerBatch": 1}, + {"source": "Upstream", "fromOutputKey": "tmp-cushion", "uomId": uom, "qtyPerBatch": 1}, + ], + # Terminal output must name the finished item (FR-MFG-05). + "outputs": [{"key": "tmp-chair", "name": "Chair", "itemId": finished_item, + "uomId": uom, "qtyPerBatch": 1}], + }, + ], + "edges": [ + {"parentKey": "tmp-cut", "childKey": "tmp-asm"}, + {"parentKey": "tmp-prep", "childKey": "tmp-asm"}, + ], + # Canvas-only decoration. No graph semantics at all — the validator never sees these, + # which is exactly what the "annotations do not affect the graph" assertion checks. + "annotations": [ + {"kind": "box", "posX": 40, "posY": 60, "width": 400, "height": 320, + "label": "Sub-assembly", "rotation": None}, + {"kind": "line", "posX": 480, "posY": 40, "width": 220, "height": 4, + "label": "Phase 2", "rotation": 90}, + ], + } + + +def cleanup(c): + """ + Find any template this script left behind, and clear the edit-lock if later scripts + started runs against it. + + Without this the script is single-use: FR-MFG-06 refuses a PUT while any run of the + template is InProgress, so a second execution would fail its very first assertion with + 409 TEMPLATE_IN_USE. Cancelling those runs is safe — they belong to the smoke suite. + """ + existing = c.get(f"/production-templates?q={TEMPLATE_CODE}").body["items"] + template = next((t for t in existing if t["code"] == TEMPLATE_CODE), None) + if template is None: + return None + + tid = template["templateId"] + if template["activeRunCount"] > 0: + reason = next((r["reasonCodeId"] for r in + c.get("/reason-codes?context=Production&pageSize=50").body["items"] + if r["code"] == "PRD-CANCEL"), None) + blocking = [r for r in c.get(f"/production-runs?templateId={tid}&status=InProgress&pageSize=200").body["items"]] + for run in blocking: + c.post(f"/production-runs/{run['runId']}/cancel", + {"reasonCodeId": reason, "note": "cancelled by m2_templates.py to clear the edit-lock"}) + print(f"cancelled {len(blocking)} in-progress run(s) to release the template edit-lock") + return tid + + +def main(): + c, chk, args = bootstrap(__doc__) + print(f"API {args.api} · AuthHex {args.auth}") + + raw_item, finished_item, uom = pick_fixtures(c, chk) + print(f"fixtures: rawItem={raw_item} finishedItem={finished_item} uom={uom}") + + stale = cleanup(c) + if stale: + print(f"note: reusing/overwriting existing template {stale} ({TEMPLATE_CODE})") + + payload = diamond(raw_item, finished_item, uom) + + # ---------------------------------------------------------------- create + chk.section("1. Create a valid diamond graph") + if stale: + head = c.get(f"/production-templates/{stale}") + created = c.put(f"/production-templates/{stale}", payload, if_match=head.etag) + chk.status("PUT existing template", created, 200) + else: + created = c.post("/production-templates", payload) + chk.status("POST /production-templates", created, 201) + + if created.status not in (200, 201): + return chk.finish("M2") + + tid = created.body["templateId"] + chk.check("ETag header present", created.etag is not None, True) + chk.check("3 stages persisted", len(created.body["stages"]), 3) + chk.check("2 edges persisted", len(created.body["edges"]), 2) + + # ------------------------------------------------------------------- get + chk.section("2. GET round-trips ids, keys, positions and fieldDefs") + got = c.get(f"/production-templates/{tid}") + chk.status("GET /production-templates/{id}", got, 200) + g = got.body + + stages = {s["name"]: s for s in g["stages"]} + chk.check("stage keys equal their ids", + all(s["key"] == str(s["stageId"]) for s in g["stages"]), True) + + cut = stages["Cut frame"] + chk.check("posX survived the round trip", float(cut["posX"]), 80.0) + chk.check("fieldDefs jsonb survived", cut["fieldDefs"][0]["key"], "moisture_ok") + chk.check("fieldDef type survived as enum name", cut["fieldDefs"][0]["type"], "Checkbox") + + asm = stages["Assemble & QA"] + chk.check("terminal has 2 upstream inputs", + sum(1 for i in asm["inputs"] if i["source"] == "Upstream"), 2) + chk.check("upstream inputs resolved fromOutputId", + all(i["fromOutputId"] for i in asm["inputs"] if i["source"] == "Upstream"), True) + chk.check("upstream inputs expose fromOutputKey", + all(i["fromOutputKey"] for i in asm["inputs"] if i["source"] == "Upstream"), True) + chk.check("terminal output carries the finished item", asm["outputs"][0]["itemId"], finished_item) + + # The builder reads activeRunCount straight off the graph to decide whether to disable + # itself; without it on this response it would need a second request to the list endpoint. + chk.check("graph exposes activeRunCount", g["activeRunCount"], 0) + + # Canvas annotations. Not in docs/30 Part C — added so a save can't silently discard the + # boxes and dividers the builder already draws. + chk.section("2b. Canvas annotations round-trip") + anns = {a["kind"]: a for a in g["annotations"]} + chk.check("both annotations persisted", len(g["annotations"]), 2) + chk.check("box label survived", anns.get("box", {}).get("label"), "Sub-assembly") + chk.check("box geometry survived", (float(anns["box"]["posX"]), float(anns["box"]["width"])), (40.0, 400.0)) + chk.check("line rotation survived", float(anns.get("line", {}).get("rotation") or 0), 90.0) + chk.check("annotations are not stages", len(g["stages"]), 3) + + bad_kind = dict(rebuild_from_get(g)) + bad_kind["annotations"] = [{"kind": "circle", "posX": 0, "posY": 0, "width": 10, + "height": 10, "label": None, "rotation": None}] + chk.status("unknown annotation kind rejected", + c.put(f"/production-templates/{tid}", bad_kind, if_match=got.etag), 422) + + # The keys GET hands back must be directly reusable as a PUT payload. + chk.section("3. Idempotent re-save using the server's own keys") + echo = rebuild_from_get(g) + resaved = c.put(f"/production-templates/{tid}", echo, if_match=got.etag) + chk.status("PUT echoing server keys", resaved, 200) + if resaved.status == 200: + chk.check("stage ids preserved (diffed, not recreated)", + sorted(s["stageId"] for s in resaved.body["stages"]), + sorted(s["stageId"] for s in g["stages"])) + chk.check("edge count still 2", len(resaved.body["edges"]), 2) + chk.check("annotations survived the echo re-save", len(resaved.body["annotations"]), 2) + etag = resaved.etag + + # Wholesale replacement cuts both ways: a client that forgets to echo annotations back + # wipes them. Pinned explicitly because that is a silent data loss, not an error. + stripped = rebuild_from_get(g) + stripped["annotations"] = [] + cleared = c.put(f"/production-templates/{tid}", stripped, if_match=etag) + chk.status("PUT omitting annotations", cleared, 200) + if cleared.status == 200: + chk.check("omitted annotations are cleared", len(cleared.body["annotations"]), 0) + restored = c.put(f"/production-templates/{tid}", rebuild_from_get(g), if_match=cleared.etag) + chk.status("PUT restoring annotations", restored, 200) + etag = restored.etag if restored.status == 200 else cleared.etag + else: + etag = got.etag + + # ------------------------------------------------------- graph rejections + chk.section("4. Graph validation rejections (FR-MFG-02, FR-MFG-04, FR-MFG-05)") + + cycle = rebuild_from_get(g) + cycle["edges"].append({"parentKey": key_of(g, "Assemble & QA"), "childKey": key_of(g, "Cut frame")}) + chk.status("cycle", c.put(f"/production-templates/{tid}", cycle, if_match=etag), 422, "GRAPH_CYCLE") + + two_term = rebuild_from_get(g) + two_term["edges"] = [e for e in two_term["edges"] if e["parentKey"] != key_of(g, "Prep cushions")] + chk.status("two terminals", c.put(f"/production-templates/{tid}", two_term, if_match=etag), + 422, "GRAPH_TERMINAL_COUNT") + + # An isolated stage has no outbound edge, so it is *also* a second terminal and the + # cheaper terminal-count check catches it first. That is the more useful error anyway — + # it names both offending stages. GRAPH_DISCONNECTED is unreachable in a valid-so-far + # DAG (see the note in ProductionGraphValidator) and is kept only as defence in depth. + orphan = rebuild_from_get(g) + orphan["stages"].append({ + "key": "tmp-orphan", "name": "Orphan stage", "estimatedMinutes": 5, + "posX": 900, "posY": 600, "fieldDefs": [], "inputs": [], + "outputs": [{"key": "tmp-orphan-out", "name": "Nothing", "uomId": uom, "qtyPerBatch": 1}], + }) + chk.status("isolated stage (reported as a second terminal)", + c.put(f"/production-templates/{tid}", orphan, if_match=etag), + 422, "GRAPH_TERMINAL_COUNT") + + # Grandparent reference: Cut -> Mid -> Asm, with Asm drawing from Cut's output. + grandparent = rebuild_from_get(g) + cut_key = key_of(g, "Cut frame") + asm_key = key_of(g, "Assemble & QA") + cut_output_key = output_key_of(g, "Cut frame", "Frame set") + grandparent["stages"].append({ + "key": "tmp-mid", "name": "Middle", "estimatedMinutes": 5, "posX": 320, "posY": 120, + "fieldDefs": [], + "inputs": [{"source": "Upstream", "fromOutputKey": cut_output_key, "uomId": uom, "qtyPerBatch": 1}], + "outputs": [{"key": "tmp-mid-out", "name": "Mid part", "uomId": uom, "qtyPerBatch": 1}], + }) + grandparent["edges"] = [e for e in grandparent["edges"] if e["parentKey"] != cut_key] + grandparent["edges"] += [{"parentKey": cut_key, "childKey": "tmp-mid"}, + {"parentKey": "tmp-mid", "childKey": asm_key}] + # Assemble still reads Cut's output, but Cut is now a grandparent -> invalid. + chk.status("upstream input from a grandparent", + c.put(f"/production-templates/{tid}", grandparent, if_match=etag), + 422, "GRAPH_INPUT_SOURCE_INVALID") + + no_item = rebuild_from_get(g) + for s in no_item["stages"]: + if s["name"] == "Assemble & QA": + s["outputs"][0]["itemId"] = None + chk.status("terminal output without an item", + c.put(f"/production-templates/{tid}", no_item, if_match=etag), + 422, "TERMINAL_OUTPUT_ITEM_REQUIRED") + + wip_item = rebuild_from_get(g) + for s in wip_item["stages"]: + if s["name"] == "Cut frame": + s["outputs"][0]["itemId"] = finished_item + chk.status("intermediate output claiming an item", + c.put(f"/production-templates/{tid}", wip_item, if_match=etag), 422) + + bad_item = rebuild_from_get(g) + for s in bad_item["stages"]: + if s["name"] == "Cut frame": + s["inputs"][0]["itemId"] = 999_999 + chk.status("stock input naming a nonexistent item", + c.put(f"/production-templates/{tid}", bad_item, if_match=etag), 422) + + chk.section("5. Concurrency + status") + chk.status("PUT with no If-Match", c.request("PUT", f"/production-templates/{tid}", rebuild_from_get(g)), + 428, "PRECONDITION_REQUIRED") + # Malformed vs stale are different failures. "AQAAAA==" is a well-formed 4-byte token + # (xmin = 1) that no live row will ever carry, so it reaches the service's version + # comparison and yields 412 rather than the 428 a garbage token would. + chk.status("PUT with a malformed If-Match", + c.put(f"/production-templates/{tid}", rebuild_from_get(g), if_match='"not-base64"'), + 428, "PRECONDITION_REQUIRED") + chk.status("PUT with a stale If-Match", + c.put(f"/production-templates/{tid}", rebuild_from_get(g), if_match='"AQAAAA=="'), + 412, "CONCURRENCY_CONFLICT") + + chk.status("PATCH status -> Inactive", + c.patch(f"/production-templates/{tid}/status", {"status": "Inactive"}), 204) + listed = c.get(f"/production-templates?q={TEMPLATE_CODE}") + row = next((t for t in listed.body["items"] if t["templateId"] == tid), None) + chk.check("list reports Inactive", row and row["status"], "Inactive") + chk.check("list reports stageCount 3", row and row["stageCount"], 3) + chk.check("list reports activeRunCount 0", row and row["activeRunCount"], 0) + + # Leave it Active so the M3 run-creation smoke can start runs from it. + c.patch(f"/production-templates/{tid}/status", {"status": "Active"}) + print(f"\nleft template {tid} ({TEMPLATE_CODE}) Active for the M3 smoke test") + + return chk.finish("M2") + + +# --- helpers: turn a GET response back into a save payload ------------------- + +def rebuild_from_get(g: dict) -> dict: + """Echo a fetched graph back as a save payload, reusing the server's keys.""" + return { + "code": g["code"], + "name": g["name"], + "description": g.get("description"), + "stages": [ + { + "key": s["key"], "name": s["name"], "roleLabel": s.get("roleLabel"), + "estimatedMinutes": s["estimatedMinutes"], "posX": s["posX"], "posY": s["posY"], + "fieldDefs": s["fieldDefs"], + "inputs": [ + {"source": i["source"], "itemId": i.get("itemId"), + "fromOutputKey": i.get("fromOutputKey"), + "uomId": i["uomId"], "qtyPerBatch": i["qtyPerBatch"]} + for i in s["inputs"] + ], + "outputs": [ + {"key": o["key"], "itemId": o.get("itemId"), "name": o["name"], + "uomId": o["uomId"], "qtyPerBatch": o["qtyPerBatch"]} + for o in s["outputs"] + ], + } + for s in g["stages"] + ], + "edges": [{"parentKey": e["parentKey"], "childKey": e["childKey"]} for e in g["edges"]], + # Echoed back deliberately: annotations are replaced wholesale, so omitting them here + # would make every re-save silently clear the canvas layout notes. + "annotations": g["annotations"], + } + + +def key_of(g: dict, stage_name: str) -> str: + return next(s["key"] for s in g["stages"] if s["name"] == stage_name) + + +def output_key_of(g: dict, stage_name: str, output_name: str) -> str: + stage = next(s for s in g["stages"] if s["name"] == stage_name) + return next(o["key"] for o in stage["outputs"] if o["name"] == output_name) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/Backend/smoke/m3_runs.py b/Backend/smoke/m3_runs.py new file mode 100644 index 0000000..de0dc52 --- /dev/null +++ b/Backend/smoke/m3_runs.py @@ -0,0 +1,218 @@ +"""M3 smoke test — run creation, list/detail, quantity override (docs/30 §D.2, FR-MFG-08/09/18). + +Still touches no stock: creating a run only copies and scales the template. Depends on the +template m2_templates.py leaves behind, so run that first: + + python Backend/smoke/m2_templates.py + python Backend/smoke/m3_runs.py +""" + +from __future__ import annotations + +import sys + +from smoke_common import bootstrap + +TEMPLATE_CODE = "SMOKE-PT-M2" +TARGET_QTY = 50 + + +def find_template(c): + listed = c.get(f"/production-templates?q={TEMPLATE_CODE}") + row = next((t for t in listed.body["items"] if t["code"] == TEMPLATE_CODE), None) + if not row: + sys.exit(f"FATAL: template {TEMPLATE_CODE} not found — run m2_templates.py first.") + return row["templateId"] + + +def main(): + c, chk, args = bootstrap(__doc__) + print(f"API {args.api}") + + tid = find_template(c) + tpl = c.get(f"/production-templates/{tid}").body + warehouse = c.get("/warehouses?pageSize=1").body["items"][0]["warehouseId"] + # Captured before creating so the script stays re-runnable — a previous run of this + # script leaves its own InProgress run behind for M4. + runs_before = next(t for t in c.get(f"/production-templates?q={TEMPLATE_CODE}").body["items"] + if t["templateId"] == tid)["activeRunCount"] + print(f"template={tid} warehouse={warehouse} targetQty={TARGET_QTY} activeRunsBefore={runs_before}") + + terminal_stage = next(s for s in tpl["stages"] if s["name"] == "Assemble & QA") + terminal_qpb = terminal_stage["outputs"][0]["qtyPerBatch"] + expected_scale = TARGET_QTY / terminal_qpb + + # ------------------------------------------------------------------ create + chk.section("1. Create a run (FR-MFG-08: scale, copy, number)") + created = c.post("/production-runs", { + "templateId": tid, "targetQty": TARGET_QTY, "warehouseId": warehouse, + }) + if not chk.status("POST /production-runs", created, 201): + return chk.finish("M3") + + run = created.body + rid = run["runId"] + chk.check("ETag header present", created.etag is not None, True) + chk.check("docNo uses the PRD sequence", run["docNo"].startswith("PRD-"), True) + chk.check("run starts InProgress", run["status"], "InProgress") + chk.check("reworkCount starts at 0", run["reworkCount"], 0) + chk.check("scaleFactor computed", float(run["scaleFactor"]), float(expected_scale)) + chk.check("3 stages copied", len(run["stages"]), 3) + chk.check("2 edges copied", len(run["edges"]), 2) + + # ------------------------------------------------------- copy-on-create + chk.section("2. Copy-on-create carries display fields and fieldDefs (FR-MFG-06)") + stages = {s["name"]: s for s in run["stages"]} + chk.check("stage names copied", sorted(stages), ["Assemble & QA", "Cut frame", "Prep cushions"]) + + cut = stages["Cut frame"] + chk.check("roleLabel copied", cut["roleLabel"], "Carpentry") + chk.check("estimatedMinutes copied", cut["estimatedMinutes"], 60) + chk.check("posX copied", float(cut["posX"]), 80.0) + chk.check("fieldDefs copied", cut["fieldDefs"][0]["key"], "moisture_ok") + chk.check("fieldValues empty before complete", cut["fieldValues"], None) + chk.check("templateStageId links back", cut["templateStageId"] is not None, True) + + # -------------------------------------------------------------- readiness + chk.section("3. Entry stages Ready, others Waiting (FR-MFG-09)") + chk.check("Cut frame is an entry", cut["isEntry"], True) + chk.check("Cut frame Ready", cut["status"], "Ready") + chk.check("Prep cushions Ready", stages["Prep cushions"]["status"], "Ready") + + asm = stages["Assemble & QA"] + chk.check("Assemble is terminal", asm["isTerminal"], True) + chk.check("Assemble is not an entry", asm["isEntry"], False) + chk.check("Assemble Waiting", asm["status"], "Waiting") + chk.check("no stage is terminal but Cut/Prep", + [s["name"] for s in run["stages"] if s["isTerminal"]], ["Assemble & QA"]) + + # ----------------------------------------------------------------- scaling + chk.section("4. Every quantity scaled by the factor (FR-MFG-08)") + tpl_stages = {s["name"]: s for s in tpl["stages"]} + ok = True + for name, rs in stages.items(): + ts = tpl_stages[name] + for ti, ri in zip(ts["inputs"], rs["inputs"]): + want = round(float(ti["qtyPerBatch"]) * expected_scale, 4) + if float(ri["plannedQty"]) != want: + ok = False + print(f" input mismatch on {name}: {ri['plannedQty']} != {want}") + for to, ro in zip(ts["outputs"], rs["outputs"]): + want = round(float(to["qtyPerBatch"]) * expected_scale, 4) + if float(ro["plannedQty"]) != want: + ok = False + print(f" output mismatch on {name}: {ro['plannedQty']} != {want}") + chk.check("all planned quantities == qtyPerBatch x scaleFactor", ok, True) + chk.check("Cut frame input scaled (8 x 50)", float(cut["inputs"][0]["plannedQty"]), 400.0) + chk.check("terminal output scaled to the target", float(asm["outputs"][0]["plannedQty"]), float(TARGET_QTY)) + + chk.check("consumed/delivered start at zero", + all(float(i["consumedQty"]) == 0 and float(i["deliveredQty"]) == 0 + for s in run["stages"] for i in s["inputs"]), True) + chk.check("cost pool starts empty", float(run["costPool"]["net"]), 0.0) + + # Upstream inputs must point at the run's own copied outputs, not the template's. + run_output_ids = {o["runOutputId"] for s in run["stages"] for o in s["outputs"]} + chk.check("upstream inputs rewired to run outputs", + all(i["fromRunOutputId"] in run_output_ids + for i in asm["inputs"] if i["source"] == "Upstream"), True) + + # -------------------------------------------------------------------- list + chk.section("5. Run board projection (FR-MFG-18)") + listed = c.get(f"/production-runs?q={run['docNo']}") + chk.status("GET /production-runs", listed, 200) + row = next((r for r in listed.body["items"] if r["runId"] == rid), None) + chk.check("run appears on the board", row is not None, True) + if row: + chk.check("stageSummary counts match", + row["stageSummary"], {"waiting": 1, "ready": 2, "inProgress": 0, "done": 0, "approved": 0}) + chk.check("templateName joined", row["templateName"], tpl["name"]) + chk.check("finished item surfaced", row["finishedItemId"], asm["outputs"][0]["itemId"]) + chk.check("finished item name joined", row["finishedItemName"] is not None, True) + + chk.check("filter by status=InProgress finds it", + any(r["runId"] == rid for r in c.get("/production-runs?status=InProgress&pageSize=200").body["items"]), True) + chk.check("filter by status=Completed excludes it", + any(r["runId"] == rid for r in c.get("/production-runs?status=Completed&pageSize=200").body["items"]), False) + chk.check("filter by templateId finds it", + any(r["runId"] == rid for r in c.get(f"/production-runs?templateId={tid}&pageSize=200").body["items"]), True) + + # -------------------------------------------------------------- edit-lock + chk.section("6. Template edit-lock now that a run is InProgress (FR-MFG-06)") + head = c.get(f"/production-templates/{tid}") + locked = c.put(f"/production-templates/{tid}", { + "code": tpl["code"], "name": tpl["name"], "description": tpl.get("description"), + "stages": [ + {"key": s["key"], "name": s["name"], "roleLabel": s.get("roleLabel"), + "estimatedMinutes": s["estimatedMinutes"], "posX": s["posX"], "posY": s["posY"], + "fieldDefs": s["fieldDefs"], + "inputs": [{"source": i["source"], "itemId": i.get("itemId"), + "fromOutputKey": i.get("fromOutputKey"), "uomId": i["uomId"], + "qtyPerBatch": i["qtyPerBatch"]} for i in s["inputs"]], + "outputs": [{"key": o["key"], "itemId": o.get("itemId"), "name": o["name"], + "uomId": o["uomId"], "qtyPerBatch": o["qtyPerBatch"]} for o in s["outputs"]]} + for s in tpl["stages"] + ], + "edges": [{"parentKey": e["parentKey"], "childKey": e["childKey"]} for e in tpl["edges"]], + }, if_match=head.etag) + chk.status("PUT template while a run is InProgress", locked, 409, "TEMPLATE_IN_USE") + + # Deactivating must stay allowed — it only blocks NEW runs (FR-MFG-01). + chk.status("PATCH status while a run is InProgress is still allowed", + c.patch(f"/production-templates/{tid}/status", {"status": "Inactive"}), 204) + chk.status("run creation from an Inactive template", + c.post("/production-runs", {"templateId": tid, "targetQty": 5, "warehouseId": warehouse}), + 422, "TEMPLATE_INACTIVE") + c.patch(f"/production-templates/{tid}/status", {"status": "Active"}) + + chk.check("activeRunCount incremented by the new run", + next(t for t in c.get(f"/production-templates?q={TEMPLATE_CODE}").body["items"] + if t["templateId"] == tid)["activeRunCount"], runs_before + 1) + + # ------------------------------------------------------------- quantities + chk.section("7. Per-run quantity override (FR-MFG-08)") + cut_input = cut["inputs"][0] + edited = c.put(f"/production-runs/{rid}/stages/{cut['runStageId']}/quantities", + {"inputs": [{"id": cut_input["runInputId"], "plannedQty": 420}], "outputs": []}) + chk.status("PUT quantities on a Ready stage", edited, 200) + if edited.status == 200: + chk.check("plannedQty updated", float(edited.body["inputs"][0]["plannedQty"]), 420.0) + chk.check("stage still Ready (no upstream inputs)", edited.body["status"], "Ready") + + chk.status("PUT quantities naming another stage's input", + c.put(f"/production-runs/{rid}/stages/{cut['runStageId']}/quantities", + {"inputs": [{"id": asm["inputs"][0]["runInputId"], "plannedQty": 9}], "outputs": []}), + 422) + + # Raising a Waiting stage's upstream input must keep it Waiting, and the edit must be + # rejected outright once a stage has started (covered in M4 once we can start one). + asm_up = next(i for i in asm["inputs"] if i["source"] == "Upstream") + bumped = c.put(f"/production-runs/{rid}/stages/{asm['runStageId']}/quantities", + {"inputs": [{"id": asm_up["runInputId"], "plannedQty": 60}], "outputs": []}) + chk.status("PUT quantities on a Waiting stage", bumped, 200) + if bumped.status == 200: + chk.check("stage stays Waiting (nothing delivered)", bumped.body["status"], "Waiting") + + chk.status("PUT quantities on a nonexistent stage", + c.put(f"/production-runs/{rid}/stages/999999/quantities", {"inputs": [], "outputs": []}), 404) + + # ------------------------------------------------------------------ events + chk.section("8. Event history records the edits") + detail = c.get(f"/production-runs/{rid}") + chk.status("GET /production-runs/{id}", detail, 200) + events = detail.body["events"] + # Two, not four: only the two successful edits are recorded. The 422 (wrong stage) and + # the 404 both throw inside ExecuteInTransactionAsync, so their event write rolls back + # with the rest of the change — history never shows an edit that did not happen. + chk.check("only successful edits are logged", + sum(1 for e in events if e["eventType"] == "QuantityEdit"), 2) + chk.check("event payload captured", + events[0]["payload"] is not None if events else False, True) + chk.check("event carries an actor", events[0]["userId"] > 0 if events else False, True) + + print(f"\nleft run {rid} ({run['docNo']}) InProgress for the M4 smoke test") + return chk.finish("M3") + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/Backend/smoke/m4_stage_actions.py b/Backend/smoke/m4_stage_actions.py new file mode 100644 index 0000000..140808b --- /dev/null +++ b/Backend/smoke/m4_stage_actions.py @@ -0,0 +1,329 @@ +"""M4 smoke test — stage start/complete/approve/transfer (docs/30 §D.3, FR-MFG-09..12). + +FIRST STOCK-TOUCHING MILESTONE. Everything happens in a dedicated `SMOKE-PRD` warehouse so +the effects are isolated from real data and easy to inspect or clean up: + + DELETE FROM stock_ledger WHERE "WarehouseId" = (SELECT "WarehouseId" FROM warehouses WHERE "Code"='SMOKE-PRD'); + +Self-contained — builds its own template and run, so it does not depend on M2/M3 leftovers: + + python Backend/smoke/m4_stage_actions.py + +Leaves the terminal stage InProgress for m5_receipt.py to complete and approve. +""" + +from __future__ import annotations + +import json +import sys + +from smoke_common import bootstrap, drain_stock, seed_costed_stock + +WAREHOUSE_CODE = "SMOKE-PRD" +TEMPLATE_CODE = "SMOKE-PT-M4" +TARGET_QTY = 50 +SEED_RAW = 1000 # base units of the raw item +SEED_PACK = 500 # base units of the packaging item +# Deliberately awkward unit costs: the raw item is seeded in two layers at different costs +# so FIFO consumption produces a genuinely weighted value rather than a round number. +RAW_COST_1 = 2.5 +RAW_COST_2 = 4.75 +PACK_COST = 1.25 +STATE_FILE = "m4_state.json" + + +def ensure_warehouse(c): + for w in c.get(f"/warehouses?q={WAREHOUSE_CODE}&pageSize=50").body["items"]: + if w["code"] == WAREHOUSE_CODE: + return w["warehouseId"] + created = c.post("/warehouses", {"code": WAREHOUSE_CODE, "name": "Production smoke warehouse"}) + if created.status != 201: + sys.exit(f"FATAL: could not create the smoke warehouse: {created.status} {created.body}") + return created.body["warehouseId"] + + +def adjustment_reason(c): + codes = c.get("/reason-codes?context=Adjustment&pageSize=50").body["items"] + if not codes: + sys.exit("FATAL: no Adjustment reason codes seeded.") + return codes[0]["reasonCodeId"] + + +def production_reason(c, code): + for r in c.get("/reason-codes?context=Production&pageSize=50").body["items"]: + if r["code"] == code: + return r["reasonCodeId"] + sys.exit(f"FATAL: Production reason {code} not seeded.") + + +def on_hand(c, item, wh): + return float(c.get(f"/stock/on-hand?itemId={item}&warehouseId={wh}").body["onHand"]) + + +def ledger_rows(c, run_id, source): + rows = c.get(f"/stock/ledger?sourceDocType={source}&sourceDocId={run_id}&pageSize=200").body["items"] + return rows + + +def seed_stock(c, wh, raw, pack, uom): + """ + Seed on-hand at explicit unit costs. Two raw layers at different costs mean the FIFO + consumption at start has to weight them, so `consumedValue` is a real number the + assertions can check rather than the 0.00 a positive adjustment would produce. + """ + seed_costed_stock(c, wh, [ + (raw, uom, SEED_RAW * 0.4, RAW_COST_1), + (raw, uom, SEED_RAW * 0.6, RAW_COST_2), + (pack, uom, SEED_PACK, PACK_COST), + ]) + + +def build_template(c, raw, pack, finished, uom): + """Cut (entry, stock input) → Assemble (terminal, upstream + a late stock input).""" + payload = { + "code": TEMPLATE_CODE, + "name": "Smoke M4 line", + "description": "Created by m4_stage_actions.py", + "stages": [ + { + "key": "tmp-cut", "name": "Cut", "roleLabel": "Carpentry", + "estimatedMinutes": 60, "posX": 80, "posY": 100, + "fieldDefs": [{"key": "moisture_ok", "label": "Moisture check", + "type": "Checkbox", "required": True}], + "inputs": [{"source": "Stock", "itemId": raw, "uomId": uom, "qtyPerBatch": 8}], + "outputs": [{"key": "tmp-frame", "name": "Frame", "uomId": uom, "qtyPerBatch": 1}], + }, + { + # A Stock input on a non-entry stage — FR-MFG-04 allows material to join late + # (packaging), which is exactly what this covers. + "key": "tmp-asm", "name": "Assemble", "roleLabel": "QA", + "estimatedMinutes": 45, "posX": 520, "posY": 100, "fieldDefs": [], + "inputs": [ + {"source": "Upstream", "fromOutputKey": "tmp-frame", "uomId": uom, "qtyPerBatch": 1}, + {"source": "Stock", "itemId": pack, "uomId": uom, "qtyPerBatch": 2}, + ], + "outputs": [{"key": "tmp-chair", "name": "Chair", "itemId": finished, + "uomId": uom, "qtyPerBatch": 1}], + }, + ], + "edges": [{"parentKey": "tmp-cut", "childKey": "tmp-asm"}], + } + + existing = next((t for t in c.get(f"/production-templates?q={TEMPLATE_CODE}").body["items"] + if t["code"] == TEMPLATE_CODE), None) + if existing: + head = c.get(f"/production-templates/{existing['templateId']}") + res = c.put(f"/production-templates/{existing['templateId']}", payload, if_match=head.etag) + if res.status == 409: + # An earlier smoke run is still InProgress; reuse the template as-is. + return existing["templateId"] + if res.status != 200: + sys.exit(f"FATAL: could not update the M4 template: {res.status} {res.body}") + return res.body["templateId"] + + res = c.post("/production-templates", payload) + if res.status != 201: + sys.exit(f"FATAL: could not create the M4 template: {res.status} {res.body}") + return res.body["templateId"] + + +def main(): + c, chk, args = bootstrap(__doc__) + print(f"API {args.api}") + + items = c.get("/items?pageSize=5&status=Active").body["items"] + if len(items) < 3: + sys.exit("FATAL: need at least 3 active items.") + raw, pack, finished = items[0]["itemId"], items[1]["itemId"], items[2]["itemId"] + uom = items[0]["baseUomId"] + + wh = ensure_warehouse(c) + drained = drain_stock(c, wh) + if drained: + print(f"drained {len(drained)} leftover item(s) from a previous execution") + seed_stock(c, wh, raw, pack, uom) + raw_before = on_hand(c, raw, wh) + pack_before = on_hand(c, pack, wh) + print(f"warehouse={wh} raw={raw}(on-hand {raw_before}) pack={pack}(on-hand {pack_before}) finished={finished}") + + tid = build_template(c, raw, pack, finished, uom) + created = c.post("/production-runs", {"templateId": tid, "targetQty": TARGET_QTY, "warehouseId": wh}) + if not chk.status("create the run", created, 201): + return chk.finish("M4") + + run = created.body + rid = run["runId"] + cut = next(s for s in run["stages"] if s["name"] == "Cut") + asm = next(s for s in run["stages"] if s["name"] == "Assemble") + cut_id, asm_id = cut["runStageId"], asm["runStageId"] + print(f"run={rid} {run['docNo']} cut={cut_id} assemble={asm_id}") + + # ------------------------------------------------------------------- start + chk.section("1. Stage start FIFO-consumes its stock inputs (FR-MFG-10)") + started = c.post(f"/production-runs/{rid}/stages/{cut_id}/start", idempotency_key="m4-start-cut") + if not chk.status("POST .../start", started, 200): + return chk.finish("M4") + + chk.check("stage now InProgress", started.body["status"], "InProgress") + chk.check("actualStartAt stamped", started.body["actualStartAt"] is not None, True) + chk.check("one input consumed", len(started.body["consumed"]), 1) + + con = started.body["consumed"][0] + chk.check("consumed the scaled quantity (8 x 50)", float(con["qty"]), 400.0) + chk.check("consumed layers reported", len(con["consumedLayers"]) >= 1, True) + chk.check("consumed value = qty x layer cost", + round(float(con["value"]), 4), + round(sum(float(l["qty"]) * float(l["unitCost"]) for l in con["consumedLayers"]), 4)) + # The whole point of seeding two layers at different costs: prove the value is genuinely + # FIFO-weighted rather than zero or a single flat rate. + chk.check("consumed value is non-zero", float(con["value"]) > 0, True) + layer_costs = {float(l["unitCost"]) for l in con["consumedLayers"]} + chk.check("consumption drew from the cheaper layer first (FR-STK-03)", + min(layer_costs), RAW_COST_1) + chk.check("ledgerRefs returned", len(started.body["ledgerRefs"]), 1) + + chk.check("on-hand fell by exactly the consumed qty", on_hand(c, raw, wh), raw_before - 400.0) + + prdi = ledger_rows(c, rid, "PRDI") + chk.check("one PRDI ledger row", len(prdi), 1) + if prdi: + chk.check("PRDI direction is Out", prdi[0]["direction"], "Out") + chk.check("PRDI qty is base-UOM 400", float(prdi[0]["qtyBase"]), 400.0) + + detail = c.get(f"/production-runs/{rid}").body + cut_now = next(s for s in detail["stages"] if s["runStageId"] == cut_id) + chk.check("consumedQty recorded on the input", float(cut_now["inputs"][0]["consumedQty"]), 400.0) + chk.check("cost pool now reflects the consumption", + float(detail["costPool"]["net"]), round(float(con["value"]), 4)) + + chk.section("2. Guards after starting") + chk.status("start again", c.post(f"/production-runs/{rid}/stages/{cut_id}/start"), + 409, "STAGE_NOT_READY") + chk.status("start a Waiting stage", c.post(f"/production-runs/{rid}/stages/{asm_id}/start"), + 409, "STAGE_NOT_READY") + chk.status("edit quantities on a started stage", + c.put(f"/production-runs/{rid}/stages/{cut_id}/quantities", + {"inputs": [{"id": cut_now["inputs"][0]["runInputId"], "plannedQty": 500}], "outputs": []}), + 409, "STAGE_NOT_EDITABLE") + + # ---------------------------------------------------------------- complete + chk.section("3. Stage complete records produced/scrap/fields (FR-MFG-11)") + cut_out = cut_now["outputs"][0]["runOutputId"] + + chk.status("complete without the required custom field", + c.post(f"/production-runs/{rid}/stages/{cut_id}/complete", + {"outputs": [{"runOutputId": cut_out, "producedQty": 50, "scrappedQty": 0}]}), + 400, "REQUIRED_FIELD_MISSING") + + chk.status("complete with scrap but no reason code", + c.post(f"/production-runs/{rid}/stages/{cut_id}/complete", + {"outputs": [{"runOutputId": cut_out, "producedQty": 50, "scrappedQty": 2}], + "fieldValues": {"moisture_ok": True}}), + 400, "REASON_CODE_REQUIRED") + + chk.status("complete with an Adjustment-context reason", + c.post(f"/production-runs/{rid}/stages/{cut_id}/complete", + {"outputs": [{"runOutputId": cut_out, "producedQty": 50, "scrappedQty": 2, + "scrapReasonCodeId": adjustment_reason(c)}], + "fieldValues": {"moisture_ok": True}}), + 422) + + chk.status("complete with scrapped > produced", + c.post(f"/production-runs/{rid}/stages/{cut_id}/complete", + {"outputs": [{"runOutputId": cut_out, "producedQty": 5, "scrappedQty": 9, + "scrapReasonCodeId": production_reason(c, "PRD-SCRAP")}], + "fieldValues": {"moisture_ok": True}}), + 422) + + done = c.post(f"/production-runs/{rid}/stages/{cut_id}/complete", + {"outputs": [{"runOutputId": cut_out, "producedQty": 50, "scrappedQty": 0}], + "fieldValues": {"moisture_ok": True}}) + chk.status("complete properly", done, 200) + if done.status == 200: + chk.check("stage now Done", done.body["status"], "Done") + chk.check("actualEndAt stamped", done.body["actualEndAt"] is not None, True) + chk.check("actualMinutes computed", done.body["actualMinutes"] is not None, True) + chk.check("producedQty recorded", float(done.body["outputs"][0]["producedQty"]), 50.0) + chk.check("availableToTransfer = produced - scrapped - transferred", + float(done.body["outputs"][0]["availableToTransfer"]), 50.0) + chk.check("fieldValues persisted", done.body["fieldValues"], {"moisture_ok": True}) + + # ----------------------------------------------------------------- approve + chk.section("4. Approve with a partial transfer (FR-MFG-12)") + approved = c.post(f"/production-runs/{rid}/stages/{cut_id}/approve", + {"transfers": [{"runOutputId": cut_out, "qty": 30}]}) + chk.status("approve transferring 30 of 50", approved, 200) + if approved.status == 200: + chk.check("stage now Approved", approved.body["status"], "Approved") + chk.check("run still InProgress (non-terminal)", approved.body["runStatus"], "InProgress") + chk.check("no receipt on a non-terminal approve", approved.body["receipt"], None) + chk.check("one transfer reported", len(approved.body["transfers"]), 1) + t = approved.body["transfers"][0] + chk.check("transferred 30", float(t["qty"]), 30.0) + chk.check("child delivered 30", float(t["childDeliveredQty"]), 30.0) + chk.check("child still Waiting (30 < 50 planned)", t["childStatus"], "Waiting") + chk.check("remainder held on the stage", + float(approved.body["stage"]["outputs"][0]["availableToTransfer"]), 20.0) + + chk.section("5. Transfer the remainder, then over-transfer (FR-MFG-12)") + chk.status("transfer 21 (more than the 20 remaining)", + c.post(f"/production-runs/{rid}/stages/{cut_id}/transfer", + {"runOutputId": cut_out, "qty": 21}), + 422, "TRANSFER_EXCEEDS_AVAILABLE") + + moved = c.post(f"/production-runs/{rid}/stages/{cut_id}/transfer", + {"runOutputId": cut_out, "qty": 20}) + chk.status("transfer the remaining 20", moved, 200) + if moved.status == 200: + chk.check("child delivered 50", float(moved.body["transfers"][0]["childDeliveredQty"]), 50.0) + chk.check("child flipped to Ready (FR-MFG-09)", moved.body["transfers"][0]["childStatus"], "Ready") + chk.check("nothing left to transfer", + float(moved.body["stage"]["outputs"][0]["availableToTransfer"]), 0.0) + + chk.status("transfer once everything is gone", + c.post(f"/production-runs/{rid}/stages/{cut_id}/transfer", + {"runOutputId": cut_out, "qty": 1}), + 422, "TRANSFER_EXCEEDS_AVAILABLE") + + # -------------------------------------------------- late stock input start + chk.section("6. Start the terminal stage — a late Stock input (FR-MFG-04)") + started2 = c.post(f"/production-runs/{rid}/stages/{asm_id}/start") + chk.status("start Assemble", started2, 200) + if started2.status == 200: + chk.check("only the Stock input consumed (upstream is WIP)", len(started2.body["consumed"]), 1) + chk.check("packaging consumed 2 x 50", float(started2.body["consumed"][0]["qty"]), 100.0) + chk.check("packaging on-hand fell by 100", on_hand(c, pack, wh), pack_before - 100.0) + chk.check("no ledger row for the upstream WIP input", len(ledger_rows(c, rid, "PRDI")), 2) + + chk.section("7. Insufficient stock is refused (FR-MFG-10)") + big = c.post("/production-runs", {"templateId": tid, "targetQty": 100000, "warehouseId": wh}) + if big.status == 201: + big_cut = next(s for s in big.body["stages"] if s["name"] == "Cut")["runStageId"] + chk.status("start a stage needing more than on-hand", + c.post(f"/production-runs/{big.body['runId']}/stages/{big_cut}/start"), + 409, "STOCK_NEGATIVE_BLOCKED") + chk.check("on-hand untouched by the failed start", on_hand(c, raw, wh), raw_before - 400.0) + else: + chk.check("could create the oversized run", big.status, 201) + + chk.section("8. Event history") + events = c.get(f"/production-runs/{rid}").body["events"] + kinds = [e["eventType"] for e in events] + chk.check("Start logged twice", kinds.count("Start"), 2) + chk.check("Complete logged once", kinds.count("Complete"), 1) + chk.check("Approve logged once", kinds.count("Approve"), 1) + chk.check("Transfer logged once", kinds.count("Transfer"), 1) + chk.check("no event for the rejected actions", kinds.count("QuantityEdit"), 0) + + # Hand off to M5. + with open(STATE_FILE, "w") as f: + json.dump({"runId": rid, "templateId": tid, "warehouseId": wh, + "assembleStageId": asm_id, "finishedItemId": finished, + "rawItemId": raw, "packItemId": pack}, f) + print(f"\nwrote {STATE_FILE}; run {rid} has Assemble InProgress for m5_receipt.py") + + return chk.finish("M4") + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/Backend/smoke/m4_state.json b/Backend/smoke/m4_state.json new file mode 100644 index 0000000..8c047c9 --- /dev/null +++ b/Backend/smoke/m4_state.json @@ -0,0 +1 @@ +{"runId": 64, "templateId": 2, "warehouseId": 4, "assembleStageId": 118, "finishedItemId": 13, "rawItemId": 18, "packItemId": 14} \ No newline at end of file diff --git a/Backend/smoke/m4b_uom_conversion.py b/Backend/smoke/m4b_uom_conversion.py new file mode 100644 index 0000000..3351e3a --- /dev/null +++ b/Backend/smoke/m4b_uom_conversion.py @@ -0,0 +1,170 @@ +"""M4b smoke test — UOM conversion on production stock inputs. + +This covers the single highest-risk correctness gap in the manufacturing phase. +`IFifoCostingService.ConsumeAsync` works exclusively in an item's BASE UOM, while +`STAGE_INPUT.uom_id` is a free FK — docs/30 never mentions conversion at all. Without the +shared `IUomConverter` (extracted from `GrnService.ToBaseAsync`), a stage input declared in +"box of 12" would consume 1 base unit instead of 12 and silently mis-cost the whole run. + +The dev database has no `uom_conversions` rows at all, so the non-base path was previously +unexercised by any data. This script creates a real conversion and proves: + + * a stage input in a non-base UOM consumes qtyPerBatch x scaleFactor x factor base units + * the ledger records the BASE quantity, not the declared one + * an input in a UOM with no conversion defined is refused with 422 rather than mis-consumed + + python Backend/smoke/m4b_uom_conversion.py +""" + +from __future__ import annotations + +import sys + +from smoke_common import bootstrap + +WAREHOUSE_CODE = "SMOKE-PRD" +TEMPLATE_CODE = "SMOKE-PT-M4B" +FACTOR = 12 # 1 case = 12 base units +QTY_PER_BATCH = 3 # cases per batch +TARGET_QTY = 10 # -> scale 10 -> 30 cases -> 360 base units +SEED = 5000 + + +def main(): + c, chk, args = bootstrap(__doc__) + print(f"API {args.api}") + + # --- fixtures --------------------------------------------------------- + wh = next((w["warehouseId"] for w in c.get(f"/warehouses?q={WAREHOUSE_CODE}&pageSize=50").body["items"] + if w["code"] == WAREHOUSE_CODE), None) + if wh is None: + sys.exit("FATAL: run m4_stage_actions.py first (it creates the SMOKE-PRD warehouse).") + + items = c.get("/items?pageSize=5&status=Active").body["items"] + raw, finished = items[0], items[1] + base_uom = raw["baseUomId"] + + uoms = c.get("/uoms?pageSize=50").body["items"] + case_uom = next((u["uomId"] for u in uoms if u["uomId"] != base_uom), None) + if case_uom is None: + sys.exit("FATAL: need at least 2 UOMs to test conversion.") + print(f"item={raw['itemId']} baseUom={base_uom} caseUom={case_uom} factor={FACTOR}") + + # --- define the conversion ------------------------------------------- + chk.section("1. Define a non-base UOM conversion for the item") + conv = c.put(f"/items/{raw['itemId']}/uom-conversions", + {"conversions": [{"fromUom": case_uom, "toUom": base_uom, "factor": FACTOR}]}) + chk.status("PUT /items/{id}/uom-conversions", conv, 200) + if conv.status != 200: + return chk.finish("M4b") + chk.check("conversion stored", any(float(x["factor"]) == FACTOR for x in conv.body["conversions"]), True) + + reason = c.get("/reason-codes?context=Adjustment&pageSize=5").body["items"][0]["reasonCodeId"] + c.post("/stock-adjustments", {"warehouseId": wh, "reasonCodeId": reason, + "lines": [{"itemId": raw["itemId"], "qtyDelta": SEED}]}) + before = float(c.get(f"/stock/on-hand?itemId={raw['itemId']}&warehouseId={wh}").body["onHand"]) + print(f"on-hand before: {before}") + + # --- template whose stock input is declared in CASES ------------------ + chk.section("2. A stage input declared in the non-base UOM") + payload = { + "code": TEMPLATE_CODE, "name": "Smoke M4b conversion line", + "stages": [{ + "key": "tmp-only", "name": "Pack", "estimatedMinutes": 10, + "posX": 0, "posY": 0, "fieldDefs": [], + # Declared in cases, not base units. + "inputs": [{"source": "Stock", "itemId": raw["itemId"], + "uomId": case_uom, "qtyPerBatch": QTY_PER_BATCH}], + "outputs": [{"key": "tmp-out", "name": "Packed", "itemId": finished["itemId"], + "uomId": base_uom, "qtyPerBatch": 1}], + }], + "edges": [], + } + + existing = next((t for t in c.get(f"/production-templates?q={TEMPLATE_CODE}").body["items"] + if t["code"] == TEMPLATE_CODE), None) + if existing: + head = c.get(f"/production-templates/{existing['templateId']}") + res = c.put(f"/production-templates/{existing['templateId']}", payload, if_match=head.etag) + tid = existing["templateId"] if res.status in (200, 409) else None + chk.check("template ready", tid is not None, True) + else: + res = c.post("/production-templates", payload) + chk.status("create single-stage template", res, 201) + tid = res.body["templateId"] if res.status == 201 else None + + if tid is None: + return chk.finish("M4b") + + # A lone stage is both the entry and the terminal — worth asserting explicitly. + run = c.post("/production-runs", {"templateId": tid, "targetQty": TARGET_QTY, "warehouseId": wh}) + chk.status("create the run", run, 201) + if run.status != 201: + return chk.finish("M4b") + + stage = run.body["stages"][0] + chk.check("single stage is both entry and terminal", + (stage["isEntry"], stage["isTerminal"]), (True, True)) + chk.check("single stage starts Ready", stage["status"], "Ready") + chk.check("plannedQty stays in the DECLARED uom (3 x 10 cases)", + float(stage["inputs"][0]["plannedQty"]), float(QTY_PER_BATCH * TARGET_QTY)) + + # --- the actual conversion assertion --------------------------------- + chk.section("3. Consumption converts cases to base units") + expected_base = QTY_PER_BATCH * TARGET_QTY * FACTOR # 3 x 10 x 12 = 360 + started = c.post(f"/production-runs/{run.body['runId']}/stages/{stage['runStageId']}/start") + chk.status("start the stage", started, 200) + if started.status != 200: + return chk.finish("M4b") + + con = started.body["consumed"][0] + chk.check(f"consumed {expected_base} BASE units, not {QTY_PER_BATCH * TARGET_QTY}", + float(con["qty"]), float(expected_base)) + chk.check("on-hand fell by the base quantity", + float(c.get(f"/stock/on-hand?itemId={raw['itemId']}&warehouseId={wh}").body["onHand"]), + before - expected_base) + + rows = c.get(f"/stock/ledger?sourceDocType=PRDI&sourceDocId={run.body['runId']}&pageSize=50").body["items"] + chk.check("one PRDI row", len(rows), 1) + if rows: + chk.check("ledger qtyBase is the converted quantity", float(rows[0]["qtyBase"]), float(expected_base)) + + detail = c.get(f"/production-runs/{run.body['runId']}").body + chk.check("consumedQty stored in base units", + float(detail["stages"][0]["inputs"][0]["consumedQty"]), float(expected_base)) + + # --- missing conversion is refused, not silently mis-consumed -------- + chk.section("4. An undefined conversion is refused (422), never assumed 1:1") + third_uom = next((u["uomId"] for u in c.get("/uoms?pageSize=50").body["items"] + if u["uomId"] not in (base_uom, case_uom)), None) + if third_uom is None: + chk.check("skipped: need a third UOM", True, True) + else: + bad = dict(payload) + bad["code"] = TEMPLATE_CODE + "-BAD" + bad["stages"] = [dict(payload["stages"][0])] + bad["stages"][0] = {**payload["stages"][0], + "inputs": [{"source": "Stock", "itemId": raw["itemId"], + "uomId": third_uom, "qtyPerBatch": 1}]} + made = c.post("/production-templates", bad) + if made.status != 201: + head = c.get(f"/production-templates?q={TEMPLATE_CODE}-BAD") + tid2 = next((t["templateId"] for t in head.body["items"] + if t["code"] == TEMPLATE_CODE + "-BAD"), None) + else: + tid2 = made.body["templateId"] + + if tid2: + run2 = c.post("/production-runs", {"templateId": tid2, "targetQty": 1, "warehouseId": wh}) + if run2.status == 201: + s2 = run2.body["stages"][0]["runStageId"] + chk.status("start a stage whose input UOM has no conversion", + c.post(f"/production-runs/{run2.body['runId']}/stages/{s2}/start"), 422) + else: + chk.check("could create the second run", run2.status, 201) + + return chk.finish("M4b") + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/Backend/smoke/m5_receipt.py b/Backend/smoke/m5_receipt.py new file mode 100644 index 0000000..e4ea40d --- /dev/null +++ b/Backend/smoke/m5_receipt.py @@ -0,0 +1,269 @@ +"""M5 smoke test — terminal approve = production receipt + cost pool (FR-MFG-13). + +Three things are proven here, the last two being the ones most likely to be silently wrong: + + A. A terminal approve creates a finished-goods layer costed at costPool / goodQty, + posts a PRDR inbound ledger entry, and completes the run. + B. Sum-of-ledger reconciliation: PRDR.value == sum(PRDI.value) - sum(PRDL.value) EXACTLY. + This is what the `valueOverride` parameter added to PostLedgerAsync exists for — the + 6 dp unit cost, multiplied out over 100+ units, drifts past the ledger's 4 dp tick. + C. A batch/serial-tracked finished item is refused rather than silently receiving + untracked stock (docs/30 defines no batch creation on receipt). + +Depends on the run m4_stage_actions.py leaves with its terminal stage InProgress: + + python Backend/smoke/m4_stage_actions.py + python Backend/smoke/m5_receipt.py +""" + +from __future__ import annotations + +import json +import os +import sys + +from smoke_common import bootstrap, drain_stock, seed_costed_stock + +STATE_FILE = "m4_state.json" +WAREHOUSE_CODE = "SMOKE-PRD" +SCRAP = 2 + +# Part B — the rounding case. The drift only appears when costPool / goodQty needs more than +# 6 decimal places, so the numbers are chosen so it does: +# consumed = 3.5 x 300 = 1050 base units at 1.234567 -> pool = 1296.29535 +# unitCost = round(1296.29535 / 300, 6) = 4.320985 (from 4.3209845, away from zero) +# naive qty x unitCost = 300 x 4.320985 = 1296.2955 != round(pool, 4) = 1296.2954 +# Without valueOverride the ledger would carry 1296.2955 and stop reconciling to the pool. +BIG_TEMPLATE_CODE = "SMOKE-PT-M5B" +BIG_TARGET = 300 +BIG_QTY_PER_BATCH = 3.5 +BIG_UNIT_COST = 1.234567 + + +def on_hand(c, item, wh): + return float(c.get(f"/stock/on-hand?itemId={item}&warehouseId={wh}").body["onHand"]) + + +def ledger_sum(c, run_id, source): + rows = c.get(f"/stock/ledger?sourceDocType={source}&sourceDocId={run_id}&pageSize=200").body["items"] + return sum(float(r["value"]) for r in rows), rows + + +def main(): + c, chk, args = bootstrap(__doc__) + print(f"API {args.api}") + + if not os.path.exists(STATE_FILE): + sys.exit(f"FATAL: {STATE_FILE} missing — run m4_stage_actions.py first.") + state = json.load(open(STATE_FILE)) + rid, wh = state["runId"], state["warehouseId"] + asm_id, finished = state["assembleStageId"], state["finishedItemId"] + + detail = c.get(f"/production-runs/{rid}").body + asm = next((s for s in detail["stages"] if s["runStageId"] == asm_id), None) + if asm is None: + sys.exit(f"FATAL: stage {asm_id} not on run {rid}.") + if asm["status"] != "InProgress": + sys.exit(f"FATAL: expected the terminal stage InProgress, found {asm['status']} — re-run m4.") + + pool_before = float(detail["costPool"]["net"]) + fin_before = on_hand(c, finished, wh) + print(f"run={rid} costPool={pool_before} finishedOnHand={fin_before}") + + # ------------------------------------------------- complete the terminal + chk.section("A1. Complete the terminal stage with scrap (FR-MFG-11)") + out_id = asm["outputs"][0]["runOutputId"] + scrap_reason = next(r["reasonCodeId"] for r in c.get("/reason-codes?context=Production&pageSize=50").body["items"] + if r["code"] == "PRD-SCRAP") + + done = c.post(f"/production-runs/{rid}/stages/{asm_id}/complete", { + "outputs": [{"runOutputId": out_id, "producedQty": 50, "scrappedQty": SCRAP, + "scrapReasonCodeId": scrap_reason}], + }) + chk.status("complete the terminal stage", done, 200) + if done.status != 200: + return chk.finish("M5") + chk.check("stage Done", done.body["status"], "Done") + chk.check("scrap recorded", float(done.body["outputs"][0]["scrappedQty"]), float(SCRAP)) + chk.check("scrap reason recorded", done.body["outputs"][0]["scrapReasonCodeId"], scrap_reason) + + # Scrap is absorbed into the pool, not written off (FR-MFG-11): no extra ledger row. + chk.check("scrap posts no ledger entry", + float(c.get(f"/production-runs/{rid}").body["costPool"]["net"]), pool_before) + + # ------------------------------------------------------------- the receipt + chk.section("A2. Terminal approve posts the receipt and completes the run (FR-MFG-13)") + good = 50 - SCRAP + approved = c.post(f"/production-runs/{rid}/stages/{asm_id}/approve") + chk.status("approve the terminal stage", approved, 200) + if approved.status != 200: + return chk.finish("M5") + + chk.check("stage Approved", approved.body["status"], "Approved") + chk.check("run Completed", approved.body["runStatus"], "Completed") + chk.check("no WIP transfers from a terminal stage", approved.body["transfers"], []) + + receipt = approved.body["receipt"] + chk.check("receipt returned", receipt is not None, True) + if receipt: + chk.check("receipt is for the finished item", receipt["itemId"], finished) + chk.check("received the good quantity (produced - scrapped)", + float(receipt["qtyReceived"]), float(good)) + chk.check("receipt warehouse is the run warehouse", receipt["warehouseId"], wh) + chk.check("layer created", receipt["layerId"] > 0, True) + + pool = approved.body["costPool"] + chk.check("cost pool reported", pool is not None, True) + if pool and receipt: + chk.check("pool net = consumed - returned", + round(float(pool["net"]), 4), + round(float(pool["consumed"]) - float(pool["returned"]), 4)) + chk.check("pool net matches the pool before approval", float(pool["net"]), pool_before) + expected_unit = round(float(pool["net"]) / float(good), 6) + chk.check("unitCost = costPool / goodQty", float(receipt["unitCost"]), expected_unit) + chk.check("receipt value = the cost pool exactly", + float(receipt["value"]), round(float(pool["net"]), 4)) + + chk.check("finished on-hand rose by the good quantity", on_hand(c, finished, wh), fin_before + good) + + completed = c.get(f"/production-runs/{rid}").body + chk.check("completedAt stamped", completed["completedAt"] is not None, True) + chk.check("run status persisted as Completed", completed["status"], "Completed") + + # ------------------------------------------------- ledger reconciliation + chk.section("A3. Ledger reconciles to the cost pool") + issued, prdi = ledger_sum(c, rid, "PRDI") + returned, _ = ledger_sum(c, rid, "PRDL") + received, prdr = ledger_sum(c, rid, "PRDR") + chk.check("one PRDR row", len(prdr), 1) + if prdr: + chk.check("PRDR direction is In", prdr[0]["direction"], "In") + chk.check("sum(PRDI) - sum(PRDL) == sum(PRDR) [the core invariant]", + round(issued - returned, 4), round(received, 4)) + print(f" issued={issued} returned={returned} received={received}") + + # --------------------------------------------------- closed-run guards + chk.section("A4. A completed run is closed to further action") + chk.status("approve again", c.post(f"/production-runs/{rid}/stages/{asm_id}/approve"), 409) + chk.status("start a stage on a completed run", + c.post(f"/production-runs/{rid}/stages/{state['assembleStageId']}/start"), 409) + chk.status("edit quantities on a completed run", + c.put(f"/production-runs/{rid}/stages/{asm_id}/quantities", {"inputs": [], "outputs": []}), 409) + + # ------------------------------------ the rounding case (>= 100 units) + chk.section("B. Rounding: 300 units, where a 6 dp unit cost drifts past the 4 dp ledger tick") + raw = state["rawItemId"] + raw_uom = next(i["baseUomId"] for i in c.get("/items?pageSize=200").body["items"] + if i["itemId"] == raw) + finished_b = state["finishedItemId"] + + # A fresh single-stage template: base-UOM input so no conversion muddies the arithmetic, + # qtyPerBatch 3.5 so the consumed quantity is NOT a multiple of the target (which is what + # forces pool / goodQty to repeat). + payload_b = { + "code": BIG_TEMPLATE_CODE, "name": "Smoke M5 rounding line", + "stages": [{ + "key": "tmp-b", "name": "Mix", "estimatedMinutes": 5, "posX": 0, "posY": 0, + "fieldDefs": [], + "inputs": [{"source": "Stock", "itemId": raw, "uomId": raw_uom, + "qtyPerBatch": BIG_QTY_PER_BATCH}], + "outputs": [{"key": "tmp-bo", "name": "Mixed", "itemId": finished_b, + "uomId": raw_uom, "qtyPerBatch": 1}], + }], + "edges": [], + } + existing_b = next((t for t in c.get(f"/production-templates?q={BIG_TEMPLATE_CODE}").body["items"] + if t["code"] == BIG_TEMPLATE_CODE), None) + if existing_b: + hb = c.get(f"/production-templates/{existing_b['templateId']}") + rb = c.put(f"/production-templates/{existing_b['templateId']}", payload_b, if_match=hb.etag) + tid = existing_b["templateId"] if rb.status in (200, 409) else None + else: + rb = c.post("/production-templates", payload_b) + tid = rb.body["templateId"] if rb.status == 201 else None + + if tid is None: + chk.check("create the rounding template", False, True) + else: + # Drain first, then seed at the exact unit cost the arithmetic above assumes. Without + # the drain, FIFO would consume whatever earlier scripts left behind (at their costs) + # and the pool would not match the figures this section reasons about — the assertions + # would still "pass" while testing something else entirely. + drain_stock(c, wh) + seed_costed_stock(c, wh, [(raw, raw_uom, 5000, BIG_UNIT_COST)]) + + big = c.post("/production-runs", {"templateId": tid, "targetQty": BIG_TARGET, "warehouseId": wh}) + if big.status != 201: + chk.check(f"create the {BIG_TARGET}-unit run", big.status, 201) + else: + brid = big.body["runId"] + bstage = big.body["stages"][0] + bout = bstage["outputs"][0]["runOutputId"] + + s = c.post(f"/production-runs/{brid}/stages/{bstage['runStageId']}/start") + chk.status("start", s, 200) + d = c.post(f"/production-runs/{brid}/stages/{bstage['runStageId']}/complete", + {"outputs": [{"runOutputId": bout, "producedQty": BIG_TARGET, "scrappedQty": 0}]}) + chk.status("complete", d, 200) + a = c.post(f"/production-runs/{brid}/stages/{bstage['runStageId']}/approve") + chk.status("approve (single stage is the terminal)", a, 200) + + if a.status == 200: + bpool = float(a.body["costPool"]["net"]) + brec = a.body["receipt"] + unit = float(brec["unitCost"]) + naive = round(unit * BIG_TARGET, 4) + chk.check("cost pool is non-zero", bpool > 0, True) + chk.check("receipt value == cost pool exactly", float(brec["value"]), round(bpool, 4)) + print(f" pool={bpool} unitCost={unit} naive qty*unit={naive}") + # This is the assertion that justifies the valueOverride parameter existing. + # If the naive product ever equals the pool, the fixture stopped exercising + # the rounding path and the test has quietly gone blind. + chk.check("naive qty x unitCost really would have drifted (fixture still valid)", + naive != round(bpool, 4), True) + + bissued, _ = ledger_sum(c, brid, "PRDI") + breturned, _ = ledger_sum(c, brid, "PRDL") + breceived, _ = ledger_sum(c, brid, "PRDR") + chk.check("sum(PRDI) - sum(PRDL) == sum(PRDR) at 300 units", + round(bissued - breturned, 4), round(breceived, 4)) + + # ------------------------------------------- tracked finished goods + chk.section("C. A batch/serial-tracked finished item is refused") + tracked = next((i for i in c.get("/items?pageSize=200&status=Active").body["items"] + if i.get("trackingMode") in ("Batch", "Serial")), None) + if tracked is None: + chk.check("skipped: no batch/serial-tracked item in the database", True, True) + print(" NOTE: the TrackingMode guard in PostReceiptAsync is unexercised here.") + else: + print(f" using tracked item {tracked['itemId']} ({tracked['trackingMode']})") + payload = { + "code": "SMOKE-PT-TRACKED", "name": "Tracked finished good", + "stages": [{ + "key": "tmp-one", "name": "Make", "estimatedMinutes": 1, "posX": 0, "posY": 0, + "fieldDefs": [], "inputs": [], + "outputs": [{"key": "tmp-o", "name": "Tracked", "itemId": tracked["itemId"], + "uomId": tracked["baseUomId"], "qtyPerBatch": 1}], + }], + "edges": [], + } + made = c.post("/production-templates", payload) + ttid = made.body["templateId"] if made.status == 201 else next( + (t["templateId"] for t in c.get("/production-templates?q=SMOKE-PT-TRACKED").body["items"] + if t["code"] == "SMOKE-PT-TRACKED"), None) + if ttid: + tr = c.post("/production-runs", {"templateId": ttid, "targetQty": 1, "warehouseId": wh}) + if tr.status == 201: + st = tr.body["stages"][0]["runStageId"] + to = tr.body["stages"][0]["outputs"][0]["runOutputId"] + c.post(f"/production-runs/{tr.body['runId']}/stages/{st}/start") + c.post(f"/production-runs/{tr.body['runId']}/stages/{st}/complete", + {"outputs": [{"runOutputId": to, "producedQty": 1, "scrappedQty": 0}]}) + chk.status("approve a tracked finished good", + c.post(f"/production-runs/{tr.body['runId']}/stages/{st}/approve"), 422) + + return chk.finish("M5") + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/Backend/smoke/m6_m7_leftover_rework_cancel.py b/Backend/smoke/m6_m7_leftover_rework_cancel.py new file mode 100644 index 0000000..74f2b3b --- /dev/null +++ b/Backend/smoke/m6_m7_leftover_rework_cancel.py @@ -0,0 +1,422 @@ +"""M6 + M7 smoke test — leftover return, reject-intake, terminal reject, run cancel. + +Covers FR-MFG-14 (leftover return at the consumed weighted cost), FR-MFG-15 (downstream +reject pulls work back to the parent), FR-MFG-16 (terminal reject resets the run for a +rework pass) and FR-MFG-17 (cancel returns net consumed stock). + +Self-contained: builds its own two-stage template and three separate runs, and drains the +warehouse first so FIFO costs are known. Run after m4 so the warehouse exists: + + python Backend/smoke/m4_stage_actions.py + python Backend/smoke/m6_m7_leftover_rework_cancel.py + +The assertions that matter most and are easiest to get silently wrong: + * a FULL leftover return must leave returnedValue == consumedValue EXACTLY (no crumb) + * reject-intake must DECREMENT the parent's transferredQty, not zero it + * a terminal reject must PRESERVE consumedQty/consumedValue and plannedQty + * a re-complete after rework must OVERWRITE producedQty, not add to it + * a rework restart with an unchanged planned qty must consume NOTHING +""" + +from __future__ import annotations + +import sys + +from smoke_common import bootstrap, drain_stock, seed_costed_stock + +WAREHOUSE_CODE = "SMOKE-PRD" +TEMPLATE_CODE = "SMOKE-PT-M67" +TARGET = 10 +RAW_QPB = 5 # 5 raw per batch -> 50 base units at target 10 +UNIT_COST = 3.0 +SEED = 4000 + + +def on_hand(c, item, wh): + return float(c.get(f"/stock/on-hand?itemId={item}&warehouseId={wh}").body["onHand"]) + + +def ledger(c, run_id, source): + return c.get(f"/stock/ledger?sourceDocType={source}&sourceDocId={run_id}&pageSize=200").body["items"] + + +def prod_reason(c, code): + for r in c.get("/reason-codes?context=Production&pageSize=50").body["items"]: + if r["code"] == code: + return r["reasonCodeId"] + sys.exit(f"FATAL: Production reason {code} not seeded.") + + +def ensure_template(c, raw, finished, uom): + """Cut (entry) -> Assemble (terminal). Cut has the stock input we return leftovers from.""" + payload = { + "code": TEMPLATE_CODE, "name": "Smoke M6/M7 line", + "stages": [ + {"key": "tmp-cut", "name": "Cut", "estimatedMinutes": 10, "posX": 0, "posY": 0, + "fieldDefs": [], + "inputs": [{"source": "Stock", "itemId": raw, "uomId": uom, "qtyPerBatch": RAW_QPB}], + "outputs": [{"key": "tmp-f", "name": "Frame", "uomId": uom, "qtyPerBatch": 1}]}, + {"key": "tmp-asm", "name": "Assemble", "estimatedMinutes": 10, "posX": 400, "posY": 0, + "fieldDefs": [], + "inputs": [{"source": "Upstream", "fromOutputKey": "tmp-f", "uomId": uom, "qtyPerBatch": 1}], + "outputs": [{"key": "tmp-c", "name": "Chair", "itemId": finished, + "uomId": uom, "qtyPerBatch": 1}]}, + ], + "edges": [{"parentKey": "tmp-cut", "childKey": "tmp-asm"}], + } + existing = next((t for t in c.get(f"/production-templates?q={TEMPLATE_CODE}").body["items"] + if t["code"] == TEMPLATE_CODE), None) + if existing: + h = c.get(f"/production-templates/{existing['templateId']}") + r = c.put(f"/production-templates/{existing['templateId']}", payload, if_match=h.etag) + if r.status in (200, 409): + return existing["templateId"] + sys.exit(f"FATAL: could not update the template: {r.status} {r.body}") + r = c.post("/production-templates", payload) + if r.status != 201: + sys.exit(f"FATAL: could not create the template: {r.status} {r.body}") + return r.body["templateId"] + + +def new_run(c, tid, wh): + r = c.post("/production-runs", {"templateId": tid, "targetQty": TARGET, "warehouseId": wh}) + if r.status != 201: + sys.exit(f"FATAL: could not create a run: {r.status} {r.body}") + cut = next(s for s in r.body["stages"] if s["name"] == "Cut") + asm = next(s for s in r.body["stages"] if s["name"] == "Assemble") + return r.body, cut, asm + + +def main(): + c, chk, args = bootstrap(__doc__) + print(f"API {args.api}") + + wh = next((w["warehouseId"] for w in c.get(f"/warehouses?q={WAREHOUSE_CODE}&pageSize=50").body["items"] + if w["code"] == WAREHOUSE_CODE), None) + if wh is None: + sys.exit("FATAL: run m4_stage_actions.py first (it creates the SMOKE-PRD warehouse).") + + items = c.get("/items?pageSize=5&status=Active").body["items"] + raw, finished = items[0]["itemId"], items[1]["itemId"] + uom = items[0]["baseUomId"] + + drain_stock(c, wh) + seed_costed_stock(c, wh, [(raw, uom, SEED, UNIT_COST)]) + tid = ensure_template(c, raw, finished, uom) + consumed_units = RAW_QPB * TARGET # 50 + consumed_value = consumed_units * UNIT_COST # 150.00 + print(f"warehouse={wh} raw={raw} unitCost={UNIT_COST} consumesPerRun={consumed_units}") + + # ===================================================================== + # M6 — leftover return + # ===================================================================== + chk.section("M6-1. Partial leftover return at the consumed weighted cost (FR-MFG-14)") + run, cut, asm = new_run(c, tid, wh) + rid = run["runId"] + cut_in = cut["inputs"][0]["runInputId"] + + c.post(f"/production-runs/{rid}/stages/{cut['runStageId']}/start") + before = on_hand(c, raw, wh) + pool0 = float(c.get(f"/production-runs/{rid}").body["costPool"]["net"]) + chk.check("cost pool after start", pool0, consumed_value) + + ret = c.post(f"/production-runs/{rid}/inputs/{cut_in}/return-leftover", + {"qty": 5, "reasonCodeId": prod_reason(c, "PRD-LEFTOVER")}) + chk.status("return 5 of 50 consumed", ret, 200) + if ret.status == 200: + chk.check("returnedQty echoed", float(ret.body["returnedQty"]), 5.0) + chk.check("returned at the consumed weighted cost", + float(ret.body["createdLayer"]["unitCost"]), UNIT_COST) + chk.check("returnedValue = qty x weighted cost", float(ret.body["returnedValue"]), 15.0) + chk.check("layer id populated", ret.body["createdLayer"]["layerId"] > 0, True) + chk.check("pool reduced by the returned value", + float(ret.body["costPool"]["net"]), consumed_value - 15.0) + chk.check("on-hand rose by the returned qty", on_hand(c, raw, wh), before + 5.0) + + prdl = ledger(c, rid, "PRDL") + chk.check("one PRDL row", len(prdl), 1) + if prdl: + chk.check("PRDL direction is In", prdl[0]["direction"], "In") + chk.check("PRDL has no bin (raw material, not the output bin)", prdl[0]["binId"], None) + + chk.section("M6-2. Guards") + chk.status("return more than remains", + c.post(f"/production-runs/{rid}/inputs/{cut_in}/return-leftover", + {"qty": 46, "reasonCodeId": prod_reason(c, "PRD-LEFTOVER")}), + 422, "LEFTOVER_EXCEEDS_CONSUMED") + chk.status("return with no reason code", + c.post(f"/production-runs/{rid}/inputs/{cut_in}/return-leftover", {"qty": 1}), + 400, "REASON_CODE_REQUIRED") + adj_reason = c.get("/reason-codes?context=Adjustment&pageSize=5").body["items"][0]["reasonCodeId"] + chk.status("return with an Adjustment-context reason", + c.post(f"/production-runs/{rid}/inputs/{cut_in}/return-leftover", + {"qty": 1, "reasonCodeId": adj_reason}), + 422) + chk.status("return against an upstream (WIP) input", + c.post(f"/production-runs/{rid}/inputs/{asm['inputs'][0]['runInputId']}/return-leftover", + {"qty": 1, "reasonCodeId": prod_reason(c, "PRD-LEFTOVER")}), + 422) + + chk.section("M6-3. A FULL return must net the input to exactly zero") + rest = c.post(f"/production-runs/{rid}/inputs/{cut_in}/return-leftover", + {"qty": 45, "reasonCodeId": prod_reason(c, "PRD-LEFTOVER")}) + chk.status("return the remaining 45", rest, 200) + if rest.status == 200: + chk.check("pool is exactly zero after a full return", float(rest.body["costPool"]["net"]), 0.0) + detail = c.get(f"/production-runs/{rid}").body + ci = detail["stages"][0]["inputs"][0] + chk.check("returnedQty == consumedQty exactly", + float(ci["returnedQty"]), float(ci["consumedQty"])) + chk.check("returnedValue == consumedValue exactly", + float(ci["returnedValue"]), float(ci["consumedValue"])) + + # Close this run out so the RUN_COST_CLOSED guard can be checked. Each step is asserted: + # letting an intermediate call fail silently here previously made the *next* assertion + # look like the bug. + cut_out = next(s for s in detail["stages"] if s["name"] == "Cut")["outputs"][0]["runOutputId"] + chk.status("close-out: complete Cut", + c.post(f"/production-runs/{rid}/stages/{cut['runStageId']}/complete", + {"outputs": [{"runOutputId": cut_out, "producedQty": TARGET, "scrappedQty": 0}]}), 200) + chk.status("close-out: approve Cut", + c.post(f"/production-runs/{rid}/stages/{cut['runStageId']}/approve"), 200) + asm_out = next(s for s in c.get(f"/production-runs/{rid}").body["stages"] + if s["name"] == "Assemble")["outputs"][0]["runOutputId"] + chk.status("close-out: start Assemble", + c.post(f"/production-runs/{rid}/stages/{asm['runStageId']}/start"), 200) + chk.status("close-out: complete Assemble", + c.post(f"/production-runs/{rid}/stages/{asm['runStageId']}/complete", + {"outputs": [{"runOutputId": asm_out, "producedQty": TARGET, "scrappedQty": 0}]}), 200) + fin = c.post(f"/production-runs/{rid}/stages/{asm['runStageId']}/approve") + chk.status("close-out: approve the terminal", fin, 200) + if fin.status == 200: + chk.check("run completed even though the pool was fully returned (cost 0)", + fin.body["runStatus"], "Completed") + chk.check("zero-cost receipt still creates a layer", fin.body["receipt"]["layerId"] > 0, True) + chk.status("return a leftover after the receipt closed the pool", + c.post(f"/production-runs/{rid}/inputs/{cut_in}/return-leftover", + {"qty": 1, "reasonCodeId": prod_reason(c, "PRD-LEFTOVER")}), + 409, "RUN_COST_CLOSED") + + # ===================================================================== + # M7a — reject-intake + # ===================================================================== + chk.section("M7-1. Reject-intake pulls work back to the parent (FR-MFG-15)") + run2, cut2, asm2 = new_run(c, tid, wh) + rid2 = run2["runId"] + c.post(f"/production-runs/{rid2}/stages/{cut2['runStageId']}/start") + d2 = c.get(f"/production-runs/{rid2}").body + cut2_out = next(s for s in d2["stages"] if s["name"] == "Cut")["outputs"][0]["runOutputId"] + c.post(f"/production-runs/{rid2}/stages/{cut2['runStageId']}/complete", + {"outputs": [{"runOutputId": cut2_out, "producedQty": TARGET, "scrappedQty": 0}]}) + start_at = next(s for s in c.get(f"/production-runs/{rid2}").body["stages"] + if s["name"] == "Cut")["actualStartAt"] + c.post(f"/production-runs/{rid2}/stages/{cut2['runStageId']}/approve") + + after_approve = c.get(f"/production-runs/{rid2}").body + a_cut = next(s for s in after_approve["stages"] if s["name"] == "Cut") + a_asm = next(s for s in after_approve["stages"] if s["name"] == "Assemble") + chk.check("child Ready before the reject", a_asm["status"], "Ready") + chk.check("parent transferred the full quantity", + float(a_cut["outputs"][0]["transferredQty"]), float(TARGET)) + + rej = c.post(f"/production-runs/{rid2}/stages/{asm2['runStageId']}/reject-intake", + {"note": "Frames warped"}) + chk.status("reject-intake on the Ready child", rej, 200) + if rej.status == 200: + chk.check("rejecting stage back to Waiting", rej.body["status"], "Waiting") + chk.check("one parent pulled back", len(rej.body["pulledBack"]), 1) + pb = rej.body["pulledBack"][0] + chk.check("pulled-back qty", float(pb["qty"]), float(TARGET)) + chk.check("parent was Approved", pb["priorParentStatus"], "Approved") + chk.check("parent reverted to InProgress", pb["parentStatus"], "InProgress") + + r_cut = next(s for s in rej.body["run"]["stages"] if s["name"] == "Cut") + r_asm = next(s for s in rej.body["run"]["stages"] if s["name"] == "Assemble") + chk.check("parent transferredQty decremented to 0", + float(r_cut["outputs"][0]["transferredQty"]), 0.0) + chk.check("parent available to transfer restored", + float(r_cut["outputs"][0]["availableToTransfer"]), float(TARGET)) + chk.check("child deliveredQty cleared", float(r_asm["inputs"][0]["deliveredQty"]), 0.0) + chk.check("parent ActualStartAt PRESERVED (FR-MFG-19)", r_cut["actualStartAt"], start_at) + chk.check("parent ActualEndAt cleared for rework", r_cut["actualEndAt"], None) + chk.check("consumed stock stays consumed", + float(r_cut["inputs"][0]["consumedQty"]), float(consumed_units)) + + chk.status("reject-intake again with nothing delivered", + c.post(f"/production-runs/{rid2}/stages/{asm2['runStageId']}/reject-intake", {}), + 409, "STAGE_REJECT_INVALID") + + chk.section("M7-2. Re-complete OVERWRITES rather than accumulating") + re_done = c.post(f"/production-runs/{rid2}/stages/{cut2['runStageId']}/complete", + {"outputs": [{"runOutputId": cut2_out, "producedQty": TARGET, "scrappedQty": 0}]}) + chk.status("re-complete the parent", re_done, 200) + if re_done.status == 200: + chk.check("producedQty overwritten, not doubled", + float(re_done.body["outputs"][0]["producedQty"]), float(TARGET)) + re_app = c.post(f"/production-runs/{rid2}/stages/{cut2['runStageId']}/approve") + chk.status("re-approve the parent", re_app, 200) + if re_app.status == 200: + chk.check("child Ready again", + next(s for s in re_app.body["stage"]["outputs"] + for _ in [0])["transferredQty"] is not None, True) + + # ===================================================================== + # M7b — terminal reject + # ===================================================================== + chk.section("M7-3. Terminal reject resets the run for a rework pass (FR-MFG-16)") + d3 = c.get(f"/production-runs/{rid2}").body + asm3 = next(s for s in d3["stages"] if s["name"] == "Assemble") + asm3_out = asm3["outputs"][0]["runOutputId"] + pool_before = float(d3["costPool"]["net"]) + + c.post(f"/production-runs/{rid2}/stages/{asm3['runStageId']}/start") + c.post(f"/production-runs/{rid2}/stages/{asm3['runStageId']}/complete", + {"outputs": [{"runOutputId": asm3_out, "producedQty": TARGET, "scrappedQty": 0}]}) + + trj = c.post(f"/production-runs/{rid2}/stages/{asm3['runStageId']}/reject", + {"note": "Final QA failed batch"}) + chk.status("terminal reject", trj, 200) + if trj.status == 200: + chk.check("reworkCount incremented", trj.body["reworkCount"], 1) + run_after = trj.body["run"] + chk.check("run still InProgress", run_after["status"], "InProgress") + chk.check("completedAt still null", run_after["completedAt"], None) + + t_cut = next(s for s in run_after["stages"] if s["name"] == "Cut") + t_asm = next(s for s in run_after["stages"] if s["name"] == "Assemble") + chk.check("entry stage reset to Ready", t_cut["status"], "Ready") + chk.check("non-entry stage reset to Waiting", t_asm["status"], "Waiting") + chk.check("timings cleared", (t_cut["actualStartAt"], t_cut["actualEndAt"]), (None, None)) + chk.check("fieldValues cleared", t_cut["fieldValues"], None) + chk.check("producedQty cleared", float(t_cut["outputs"][0]["producedQty"]), 0.0) + chk.check("transferredQty cleared", float(t_cut["outputs"][0]["transferredQty"]), 0.0) + chk.check("deliveredQty cleared", float(t_asm["inputs"][0]["deliveredQty"]), 0.0) + + # The load-bearing half of FR-MFG-16. + chk.check("plannedQty PRESERVED", float(t_cut["inputs"][0]["plannedQty"]), float(consumed_units)) + chk.check("consumedQty PRESERVED", float(t_cut["inputs"][0]["consumedQty"]), float(consumed_units)) + chk.check("cost pool PRESERVED across the rework", float(run_after["costPool"]["net"]), pool_before) + + snap = [e for e in run_after["events"] if e["eventType"] == "TerminalReject"] + chk.check("exactly one snapshot event", len(snap), 1) + if snap: + chk.check("snapshot records the rework number", snap[0]["payload"]["reworkNumber"], 1) + chk.check("snapshot captured every stage", len(snap[0]["payload"]["stages"]), 2) + chk.check("snapshot kept the pre-reset produced figure", + any(float(o["producedQty"]) == TARGET + for s in snap[0]["payload"]["stages"] for o in s["outputs"]), True) + chk.check("reject note recorded", snap[0]["note"], "Final QA failed batch") + + # This is the single behavioural rule that makes FR-MFG-16 work: a start always consumes + # max(0, plannedBase - consumedQty), never the full planned figure. After a rework the + # material is still in the pool, so re-consuming it would double-charge the run. + chk.section("M7-4. Rework restart after RAISING the planned qty consumes only the delta") + cut2_in = next(i for s in c.get(f"/production-runs/{rid2}").body["stages"] + for i in s["inputs"] if s["name"] == "Cut")["runInputId"] + raised = consumed_units + 10 + chk.status("raise the planned qty on the reset (Ready) stage", + c.put(f"/production-runs/{rid2}/stages/{cut2['runStageId']}/quantities", + {"inputs": [{"id": cut2_in, "plannedQty": raised}], "outputs": []}), 200) + + oh_before = on_hand(c, raw, wh) + pool_pre = float(c.get(f"/production-runs/{rid2}").body["costPool"]["net"]) + restart = c.post(f"/production-runs/{rid2}/stages/{cut2['runStageId']}/start") + chk.status("restart after the raise", restart, 200) + if restart.status == 200: + chk.check("consumed ONLY the 10-unit delta, not the full 60", + float(restart.body["consumed"][0]["qty"]), 10.0) + chk.check("on-hand fell by only the delta", on_hand(c, raw, wh), oh_before - 10.0) + chk.check("consumedQty accumulated to the new planned total", + float(next(i for s in c.get(f"/production-runs/{rid2}").body["stages"] + for i in s["inputs"] if i["runInputId"] == cut2_in)["consumedQty"]), + float(raised)) + chk.check("pool grew by only the delta's value", + float(c.get(f"/production-runs/{rid2}").body["costPool"]["net"]), + pool_pre + 10.0 * UNIT_COST) + + chk.section("M7-5. A second rework, restarted UNCHANGED, consumes nothing at all") + # Drive the run round again to get the entry stage back to Ready with consumed == planned. + d5 = c.get(f"/production-runs/{rid2}").body + c5 = next(s for s in d5["stages"] if s["name"] == "Cut") + a5 = next(s for s in d5["stages"] if s["name"] == "Assemble") + c.post(f"/production-runs/{rid2}/stages/{c5['runStageId']}/complete", + {"outputs": [{"runOutputId": c5["outputs"][0]["runOutputId"], + "producedQty": TARGET, "scrappedQty": 0}]}) + c.post(f"/production-runs/{rid2}/stages/{c5['runStageId']}/approve") + c.post(f"/production-runs/{rid2}/stages/{a5['runStageId']}/start") + c.post(f"/production-runs/{rid2}/stages/{a5['runStageId']}/complete", + {"outputs": [{"runOutputId": a5["outputs"][0]["runOutputId"], + "producedQty": TARGET, "scrappedQty": 0}]}) + second = c.post(f"/production-runs/{rid2}/stages/{a5['runStageId']}/reject", {"note": "again"}) + chk.status("second terminal reject", second, 200) + if second.status == 200: + chk.check("reworkCount now 2", second.body["reworkCount"], 2) + chk.check("two snapshot events retained", + sum(1 for e in second.body["run"]["events"] if e["eventType"] == "TerminalReject"), 2) + + oh2 = on_hand(c, raw, wh) + prdi2 = len(ledger(c, rid2, "PRDI")) + again = c.post(f"/production-runs/{rid2}/stages/{c5['runStageId']}/start") + chk.status("restart with planned unchanged", again, 200) + if again.status == 200: + chk.check("nothing consumed (delta is zero)", len(again.body["consumed"]), 0) + chk.check("on-hand unchanged", on_hand(c, raw, wh), oh2) + chk.check("no new PRDI ledger row", len(ledger(c, rid2, "PRDI")), prdi2) + + chk.section("M7-6. Cancel returns net consumed stock (FR-MFG-17)") + run4, cut4, _ = new_run(c, tid, wh) + rid4 = run4["runId"] + in4 = cut4["inputs"][0]["runInputId"] + c.post(f"/production-runs/{rid4}/stages/{cut4['runStageId']}/start") + first = float(next(i for s in c.get(f"/production-runs/{rid4}").body["stages"] + for i in s["inputs"] if i["runInputId"] == in4)["consumedQty"]) + chk.check("first start consumed the full planned qty", first, float(consumed_units)) + + # ===================================================================== + # M7c — cancel + # ===================================================================== + oh_pre_cancel = on_hand(c, raw, wh) + cancelled = c.post(f"/production-runs/{rid4}/cancel", + {"reasonCodeId": prod_reason(c, "PRD-CANCEL"), "note": "Order cancelled"}) + chk.status("cancel the run", cancelled, 200) + if cancelled.status == 200: + chk.check("run Cancelled", cancelled.body["status"], "Cancelled") + chk.check("one return posted", len(cancelled.body["returns"]), 1) + r0 = cancelled.body["returns"][0] + chk.check("returned the net consumed qty", float(r0["qty"]), float(consumed_units)) + chk.check("returned at the consumed weighted cost", float(r0["unitCost"]), UNIT_COST) + chk.check("layer id populated", r0["layerId"] > 0, True) + chk.check("ledgerRefs populated", len(cancelled.body["ledgerRefs"]), 1) + chk.check("on-hand restored", on_hand(c, raw, wh), oh_pre_cancel + consumed_units) + + prdc = ledger(c, rid4, "PRDC") + chk.check("one PRDC row", len(prdc), 1) + if prdc: + chk.check("PRDC direction is In", prdc[0]["direction"], "In") + chk.check("PRDC value = the exact consumed residual", + float(prdc[0]["value"]), consumed_units * UNIT_COST) + + after_cancel = c.get(f"/production-runs/{rid4}").body + chk.check("cancel reason recorded", after_cancel["cancelReasonCodeId"] is not None, True) + chk.check("completedAt stays null on a cancel", after_cancel["completedAt"], None) + chk.check("pool nets to zero after the cancel return", + float(after_cancel["costPool"]["net"]), 0.0) + chk.check("cancel event logged", + any(e["eventType"] == "Cancel" for e in after_cancel["events"]), True) + + chk.section("M7-7. Cancel guards") + chk.status("cancel an already-cancelled run", + c.post(f"/production-runs/{rid4}/cancel", {"reasonCodeId": prod_reason(c, "PRD-CANCEL")}), + 409, "RUN_NOT_CANCELLABLE") + chk.status("cancel a COMPLETED run", + c.post(f"/production-runs/{rid}/cancel", {"reasonCodeId": prod_reason(c, "PRD-CANCEL")}), + 409, "RUN_NOT_CANCELLABLE") + run5, _, _ = new_run(c, tid, wh) + chk.status("cancel with no reason code", + c.post(f"/production-runs/{run5['runId']}/cancel", {}), 400, "REASON_CODE_REQUIRED") + + return chk.finish("M6+M7") + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/Backend/smoke/run_all.py b/Backend/smoke/run_all.py new file mode 100644 index 0000000..ea6cb51 --- /dev/null +++ b/Backend/smoke/run_all.py @@ -0,0 +1,70 @@ +"""Run the whole manufacturing smoke suite in dependency order. + + python Backend/smoke/run_all.py + +Order matters: m4 creates the isolated SMOKE-PRD warehouse and drains it, m5 consumes the +run m4 leaves with its terminal stage InProgress. Each script is individually re-runnable, +but m5 deliberately refuses to run twice against an already-approved terminal stage — that +guard is what stops it silently asserting against the wrong state. + +Prerequisites: ERPCore on :5224 and AuthHex on :5602 (override with ERP_SMOKE_API / +ERP_SMOKE_AUTH / ERP_SMOKE_USER / ERP_SMOKE_PASSWORD). +""" + +from __future__ import annotations + +import re +import subprocess +import sys +from pathlib import Path + +SCRIPTS = [ + ("M2 templates + graph validation", "m2_templates.py"), + ("M3 run creation / board / quantities", "m3_runs.py"), + ("M4 stage start / complete / approve / transfer", "m4_stage_actions.py"), + ("M4b UOM conversion on stock inputs", "m4b_uom_conversion.py"), + ("M5 terminal receipt + cost pool", "m5_receipt.py"), + ("M6+M7 leftover / rework / cancel", "m6_m7_leftover_rework_cancel.py"), +] + +SUMMARY = re.compile(r"^(\S+): (\d+)/(\d+) assertions passed") + + +def main() -> int: + here = Path(__file__).parent + results = [] + failed = False + + for label, script in SCRIPTS: + print(f"\n{'=' * 70}\n{label} ({script})\n{'=' * 70}", flush=True) + proc = subprocess.run( + [sys.executable, script, *sys.argv[1:]], + cwd=here, capture_output=True, text=True, encoding="utf-8", errors="replace", + ) + sys.stdout.write(proc.stdout) + if proc.stderr.strip(): + sys.stderr.write(proc.stderr) + + passed = total = 0 + for line in proc.stdout.splitlines(): + m = SUMMARY.match(line.strip()) + if m: + passed, total = int(m.group(2)), int(m.group(3)) + results.append((label, passed, total, proc.returncode)) + if proc.returncode != 0: + failed = True + + print(f"\n{'=' * 70}\nSUITE SUMMARY\n{'=' * 70}") + grand_passed = grand_total = 0 + for label, passed, total, rc in results: + grand_passed += passed + grand_total += total + state = "OK " if rc == 0 else "FAIL" + print(f" [{state}] {label:<48} {passed}/{total}") + print(f"\n TOTAL: {grand_passed}/{grand_total} assertions" + + (" — ALL GREEN" if not failed else " (SUITE FAILED)")) + return 1 if failed else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/Backend/smoke/smoke_common.py b/Backend/smoke/smoke_common.py new file mode 100644 index 0000000..c3ed12a --- /dev/null +++ b/Backend/smoke/smoke_common.py @@ -0,0 +1,259 @@ +"""Shared harness for the manufacturing smoke tests (docs/30-BACKEND-PHASE2.md). + +The repo has no test project; verification is a live smoke test against local Postgres +with a real AuthHex session, with the assertion count recorded in Backend/PROGRESS.md. +These scripts make that repeatable instead of ad-hoc curl. + +Auth note: ERPCore validates AuthHex's RS256 tokens offline against a statically +configured public key, so we log in to AuthHex *directly* and send the access token as a +Bearer header. That deliberately bypasses ERPCore's own /auth/login proxy, which would +otherwise need AuthHex:BaseUrl to match the port AuthHex actually listens on. + +Usage: + python m2_templates.py [--api URL] [--auth URL] [--user EMAIL] [--password PW] + +Environment variables (ERP_SMOKE_API, ERP_SMOKE_AUTH, ERP_SMOKE_USER, +ERP_SMOKE_PASSWORD) override the defaults; command-line flags override those. +""" + +from __future__ import annotations + +import argparse +import json +import os +import sys +import urllib.error +import urllib.request + +# Server messages and box-drawing output contain non-cp1252 characters, and the default +# Windows console codepage would raise UnicodeEncodeError mid-report — losing exactly the +# diagnostic text a failing assertion needs to show. +for _stream in (sys.stdout, sys.stderr): + try: + _stream.reconfigure(encoding="utf-8", errors="replace") + except (AttributeError, ValueError): + pass + +DEFAULTS = { + "api": "http://localhost:5224/api/v1", + "auth": "http://localhost:5602", + "user": "admin@gmail.com", + "password": "Naveen@99", +} + + +def parse_args(description: str) -> argparse.Namespace: + p = argparse.ArgumentParser(description=description) + for key, default in DEFAULTS.items(): + p.add_argument(f"--{key}", default=os.environ.get(f"ERP_SMOKE_{key.upper()}", default)) + return p.parse_args() + + +class Response: + __slots__ = ("status", "body", "headers") + + def __init__(self, status: int, body, headers: dict): + self.status = status + self.body = body + self.headers = headers + + @property + def code(self): + """The RFC 7807 domain error code, when the body carries one (docs/11 §1.8).""" + return self.body.get("code") if isinstance(self.body, dict) else None + + @property + def etag(self): + return self.headers.get("ETag") + + def __repr__(self): + return f"<{self.status} code={self.code}>" + + +class Client: + def __init__(self, api: str, token: str): + self.api = api.rstrip("/") + self.token = token + + def request(self, method: str, path: str, body=None, if_match: str | None = None, + idempotency_key: str | None = None) -> Response: + url = f"{self.api}{path}" + data = json.dumps(body).encode() if body is not None else None + req = urllib.request.Request(url, data=data, method=method) + req.add_header("Accept", "application/json") + req.add_header("Authorization", f"Bearer {self.token}") + if data is not None: + req.add_header("Content-Type", "application/json") + if if_match: + req.add_header("If-Match", if_match) + if idempotency_key: + req.add_header("Idempotency-Key", idempotency_key) + + try: + with urllib.request.urlopen(req) as r: + raw = r.read() + return Response(r.status, _decode(raw), dict(r.headers)) + except urllib.error.HTTPError as e: + raw = e.read() + return Response(e.code, _decode(raw), dict(e.headers)) + + def get(self, path): + return self.request("GET", path) + + def post(self, path, body=None, **kw): + return self.request("POST", path, body, **kw) + + def put(self, path, body=None, **kw): + return self.request("PUT", path, body, **kw) + + def patch(self, path, body=None, **kw): + return self.request("PATCH", path, body, **kw) + + +def _decode(raw: bytes): + if not raw: + return None + try: + return json.loads(raw) + except json.JSONDecodeError: + return raw.decode(errors="replace") + + +def login(auth_url: str, identifier: str, password: str) -> str: + """Obtain an AuthHex access token via its `{functionName, payload}` envelope.""" + payload = { + "functionName": "loginUser", + "payload": {"identifier": identifier, "password": password, "deviceName": "erp-smoke"}, + "reference": "", + } + req = urllib.request.Request( + f"{auth_url.rstrip('/')}/api/user", + data=json.dumps(payload).encode(), + method="POST", + headers={"Content-Type": "application/json"}, + ) + try: + with urllib.request.urlopen(req) as r: + envelope = json.loads(r.read()) + except urllib.error.URLError as e: + sys.exit(f"FATAL: cannot reach AuthHex at {auth_url} ({e}). Start ERP_Auth_Service first.") + + if not envelope.get("success") or not envelope.get("data"): + sys.exit(f"FATAL: AuthHex login failed: {envelope.get('message')!r}") + return envelope["data"]["accessToken"] + + +class Checker: + """Counts assertions so the pass total can be recorded in PROGRESS.md.""" + + def __init__(self): + self.passed = 0 + self.failed = 0 + + def check(self, label: str, actual, expected) -> bool: + ok = actual == expected + if ok: + self.passed += 1 + print(f" PASS {label}") + else: + self.failed += 1 + print(f" FAIL {label}\n expected: {expected!r}\n actual: {actual!r}") + return ok + + def status(self, label: str, response: Response, expected_status: int, expected_code: str | None = None): + ok = self.check(f"{label} -> {expected_status}", response.status, expected_status) + if expected_code is not None: + ok = self.check(f"{label} -> code {expected_code}", response.code, expected_code) and ok + if not ok and response.status >= 400: + detail = response.body.get("detail") if isinstance(response.body, dict) else response.body + print(f" server said: {detail}") + return ok + + def section(self, title: str): + print(f"\n--- {title} ---") + + def finish(self, name: str) -> int: + total = self.passed + self.failed + print(f"\n{'=' * 60}\n{name}: {self.passed}/{total} assertions passed" + + (f" ({self.failed} FAILED)" if self.failed else " — ALL GREEN") + + f"\n{'=' * 60}") + return 1 if self.failed else 0 + + +def bootstrap(description: str): + """Standard entry point: parse args, log in, return (client, checker, args).""" + args = parse_args(description) + token = login(args.auth, args.user, args.password) + return Client(args.api, token), Checker(), args + + +# --- stock fixtures ---------------------------------------------------------- +# +# Seeding matters more than it looks. A positive stock ADJUSTMENT is the obvious way to +# create on-hand, but StockMutator's inbound path costs it at *last cost*, which is 0.00 +# when the item has no prior layers. Stock seeded that way makes every cost-pool assertion +# pass trivially against zeros and proves nothing. A direct (no-PO) GRN lets us state the +# unit cost explicitly, so consumption produces a real, checkable value. + + +def drain_stock(c, warehouse_id: int) -> list: + """ + Zero out every item's on-hand in a warehouse via one negative adjustment. + + Needed because these scripts are re-runnable and FIFO is oldest-first: stock left behind + by a previous execution is consumed *before* anything seeded now. If an earlier run left + zero-cost layers (as an adjustment-based seed does), a later run's cost assertions would + silently read 0.00 and pass against nothing. Draining first makes each execution start + from a known-empty warehouse. + """ + rows = c.get(f"/stock/on-hand/list?warehouseId={warehouse_id}&pageSize=200").body["items"] + lines = [{"itemId": r["itemId"], "qtyDelta": -float(r["onHand"])} + for r in rows if float(r["onHand"]) > 0] + if not lines: + return [] + + reasons = c.get("/reason-codes?context=Adjustment&pageSize=5").body["items"] + if not reasons: + sys.exit("FATAL: no Adjustment reason codes seeded.") + + res = c.post("/stock-adjustments", { + "warehouseId": warehouse_id, + "reasonCodeId": reasons[0]["reasonCodeId"], + "lines": lines, + }) + if res.status != 201: + sys.exit(f"FATAL: could not drain the smoke warehouse: {res.status} {res.body}") + return lines + + +def ensure_vendor(c) -> int: + existing = c.get("/vendors?pageSize=1").body["items"] + if existing: + return existing[0]["vendorId"] + created = c.post("/vendors", {"code": "SMOKE-V", "name": "Smoke vendor"}) + if created.status != 201: + sys.exit(f"FATAL: could not create a vendor: {created.status} {created.body}") + return created.body["vendorId"] + + +def seed_costed_stock(c, warehouse_id: int, lines, vendor_id: int | None = None) -> None: + """ + Create on-hand at explicit unit costs via a direct GRN + confirm. + + `lines` is an iterable of (item_id, uom_id, qty, unit_cost). + """ + vendor_id = vendor_id or ensure_vendor(c) + grn = c.post("/grns", { + "vendorId": vendor_id, + "warehouseId": warehouse_id, + "lines": [ + {"itemId": i, "uomId": u, "qty": q, "unitCost": cost, "discountPct": 0, "vatPct": 0} + for (i, u, q, cost) in lines + ], + }) + if grn.status != 201: + sys.exit(f"FATAL: could not create the seeding GRN: {grn.status} {grn.body}") + + confirmed = c.post(f"/grns/{grn.body['grnId']}/confirm") + if confirmed.status != 200: + sys.exit(f"FATAL: could not confirm the seeding GRN: {confirmed.status} {confirmed.body}") diff --git a/Frontend/PROGRESS.md b/Frontend/PROGRESS.md index 817c9c1..90d3a13 100644 --- a/Frontend/PROGRESS.md +++ b/Frontend/PROGRESS.md @@ -115,6 +115,60 @@ Spec: `docs/21-FRONTEND-HRM.md` (flows + rules) · `docs/13-BACKEND-HRM-API.md` - **Leave reject uses a native `window.prompt`** instead of a dialog — functionally correct, but a lower-fidelity UX than the rest of the app's dialog-based patterns. - **A pre-existing, unrelated syntax error in `app/dashboard/receiving/grn/new/page.tsx`** (unclosed JSX, last touched 2026-07-23 before this HRM pass started) blocks a clean whole-project `tsc --noEmit` run. Not introduced by this work and not fixed by it — confirmed via `git status`/`git log` that this file was untouched this session; scoped `eslint`/`tsc` checks against every HRM file individually (and the fact this is the *only* file `tsc` reports) confirm the HRM additions themselves are clean. +--- + +# Manufacturing — Production Lines (Phase 2) + +Spec: `docs/21-FRONTEND-PHASE2.md` (flows/screens) · contract: `docs/30-BACKEND-PHASE2.md` (§D.1–D.3). Validation posture: `docs/20-FRONTEND.md §3` — client checks are UX only. + +> **Every production screen now runs on the real API. Both mock modules are deleted.** `npx tsc --noEmit` reports 0 errors in this module (the only 4 project errors are pre-existing HRM ones — see the note at the end of §13), and `npx next build` reports **"Compiled successfully"** before failing type-check on those same HRM files. **Nothing has been driven in a browser** — see the honesty note at the end. + +## 11. Contract layer (F1) — DONE +- [x] `types/production.ts` **fully rewritten** against docs/30 Part D — every request/response DTO, all six enums, and the stage-action result shapes. Replaces the frontend-only placeholder shapes entirely +- [x] Three contract corrections carried through: templates are keyed by **`code`** (not `docNo` — only runs get a document number); quantities use **`itemId`/`uomId`/`qtyPerBatch`** numeric FKs (not free-text uom/qty); stages carry **`posX`/`posY`**, so canvas layout round-trips through the server +- [x] `lib/api/production-templates.ts` — list/get/create/update/updateStatus with ETag + `If-Match` +- [x] `lib/api/production-runs.ts` — the full §D.3 surface (start, complete, approve, transfer, reject-intake, reject, return-leftover, cancel, quantities), every action taking an `idempotencyKey`; plus `isStaleStageError()` for the docs/21 §6 "409 on a stage-status code → refetch silently" rule +- [x] `lib/error-map.ts` — all 17 docs/30 §D.4 codes. **Also fixed a real mechanism gap:** `errorMessage()` let any mapped domain code override the server's `detail`, which would have thrown away the specifics the user needs — the graph validator names the offending stages, and the transfer/leftover guards quote the actual figures. Added `DETAIL_PREFERRED_CODES` so those eight codes let `detail` win and keep their map entry as a fallback + +## 12. Screens (F2–F5) — DONE +- [x] **Template overview** (`app/dashboard/production/templates/page.tsx`) — real `productionTemplatesApi.list` with a 300 ms debounced search, status filter, pagination and real `activeRunCount`. One-row-per-template canvas labelled from live data +- [x] **Template builder** (`templates/[id]/page.tsx`) — **fully rewired.** GETs the graph, holds the ETag, and the former `handleSave()` toast stub is now a real create/update. Node ids **are** the server's stage keys (`tmp-` for stages drawn this session), so a PUT diffs stages in place and keeps historical runs linked; `node.position` persists as `posX`/`posY`; real `itemsApi`/`uomsApi` pickers replaced `MOCK_ITEMS`; `/templates/new` renders an unsaved draft seeded from the overview dialog's query params and swaps its URL on first save. Also gained a Deactivate/Activate control — `productionTemplatesApi.updateStatus` previously had no UI path at all +- [x] **Run board** (`runs/page.tsx`) — real list with debounced doc-no search, template/warehouse/status filters and pagination. Start dialog posts `productionRunsApi.create` and **navigates to the run** +- [x] **Run detail** (`runs/[id]/page.tsx`) — canvas built from the run's own `posX`/`posY` and run edges, with per-stage intake (`delivered/planned`) and available-to-transfer badges, live cost pool, and a `stageSummary` computed from real stage statuses +- [x] **Stage drawer** (`runs/[id]/StageDrawer.tsx`) — the whole of docs/21 §5: per-status bodies (Waiting → explanation · Ready → editable planned quantities + Start · InProgress → produced/scrapped per output with a required Production reason + custom fields + Complete · Done non-terminal → approve with optional partial transfer · Done terminal → receipt preview + Approve & receive + Reject for rework · Approved → transfer remainder), reject-intake from Ready **or** Waiting-with-deliveries, and the per-stage event timeline +- [x] **Runtime custom-field renderer** (`runs/[id]/CustomFieldForm.tsx`) — `fieldDefs` → typed inputs for all five types, plus `missingRequiredFields()` which **mirrors the server's rule exactly**, including the part that surprises people: an unchecked Checkbox counts as *provided* (`false`), so a required checkbox does not force a tick +- [x] **Run-level actions** (`runs/[id]/RunActions.tsx`) — Return leftover (per consumed Stock input, showing consumed/returned/weighted cost, in base UOM and capped at the unreturned remainder) and Cancel run (previewing what goes back to stock). Both hidden once the run leaves InProgress, because `RUN_COST_CLOSED`/`RUN_NOT_CANCELLABLE` mean offering them could only produce an error +- [x] `lib/production-status-colors.ts` kept untouched — it already matches docs/21 §3 exactly and is the single source for status colour everywhere +- [x] **Deleted `lib/production-mock-runs.ts` and `lib/production-mock-templates.ts`**, including `buildStagePlan()` + +**Deviations / decisions (recorded):** +- **The drawer is one file, not the seven the plan sketched.** Each per-status panel is ~30 lines and they all share the same lookup helpers, `submit()` wrapper and error handling; splitting them would mean threading that shared context through seven prop lists for no isolation benefit. `CustomFieldForm` and `RunActions` *are* separate, because both stand alone and neither needs the drawer's form state. +- **The board shows per-status counts, not named stages.** The list projection carries `stageSummary` only, so naming stages there would mean guessing which stage holds which count — exactly what the deleted `buildStagePlan()` did. Named per-stage state lives on the run detail, where the server actually returns it. +- **Non-terminal outputs have their `itemId` stripped on save, not rejected.** A stage that *was* terminal and then gained a child keeps its picked item in local state with the field no longer rendered; an issue-list message about an invisible field would be unactionable, so the builder drops it silently (FR-MFG-05 forbids it on a WIP output anyway). +- **The terminal receipt preview is computed client-side.** There is no preview endpoint and every input (cost pool, produced, scrapped) is already on the page, so the drawer mirrors the server's arithmetic to show the layer *before* creating it. Preview only — the server recomputes. +- **A status toggle re-reads the ETag.** `PATCH /status` bumps the row's `xmin`, invalidating the token the builder holds. It re-GETs and takes *only* the etag and status, deliberately not reloading the canvas, because a full reload there would silently discard unsaved edits. +- **"New Template" opens an unsaved draft rather than creating immediately.** A template cannot exist without a valid graph — the server requires ≥1 stage and a terminal output naming a real item (FR-MFG-02/05) — so there is nothing sensible to POST from a name alone. +- **`templateGraphToSaveRequest()` was deleted from `lib/api/production-templates.ts`.** It converted a fetched graph into a save payload, but the builder's canvas — not the last GET — is the source of truth for what gets saved, so it had no caller and would have drifted. + +**Backend additions made for these screens** (all amended into docs/30 as built): +- **`TemplateSummaryDto.stageNames`, in flow order.** The overview draws each template as a line left-to-right and needs the names for every row; without the field the client would fetch every template's full graph just to label boxes. Ordering by stage id turned out to be insertion order, which put the *terminal* stage first and drew lines backwards — so the server toposorts (Kahn, tie-broken by id for stability, falling back to id order if the graph is ever cyclic so a listing can't fail on bad data). +- **`TemplateGraphDto.activeRunCount`.** The builder reads its edit-locked state straight off the graph; without it, it would need a second request to the list endpoint purely to know whether to disable itself. +- **`production_templates.Annotations` (jsonb) + `SaveTemplateRequest.annotations`.** The canvas already drew grouping boxes and divider lines and the contract had nowhere to keep them, so every save would have silently discarded the user's layout notes. Round-tripped verbatim, capped at 200 entries, `kind` validated to `box`/`line`, and invisible to the graph validator. Migration `AddTemplateCanvasAnnotations`. Note the flip side, pinned by a smoke assertion: replacement is wholesale, so a client that forgets to echo `annotations` back on a PUT clears them. + +## 13. Validation posture (F6) — DONE +- [x] Domain-code → message map complete (§11), with `detail` preferred where the server is more specific +- [x] `412 CONCURRENCY_CONFLICT` amber conflict banner + Reload on the builder (the `app/dashboard/vendors/[id]/page.tsx` pattern) +- [x] `409 TEMPLATE_IN_USE` edit-lock banner driven by the server. Two distinct messages: locked on load (`activeRunCount > 0`) versus locked *while editing* — the FR-MFG-06 TOCTOU, where a run starts between the GET and the PUT. The second locks the canvas rather than reloading, so nothing the user just drew disappears without an explanation +- [x] `422 GRAPH_*` focuses the offending stage — a best-effort substring match of the server's `detail` against stage names, which is why the validator quotes them. Advisory by design: the full message is always in the banner too, so an ambiguous name costs a highlight, never the explanation +- [x] `Idempotency-Key` per action (`useRef(crypto.randomUUID())`, re-minted after each success and whenever the drawer switches stage) +- [x] Silent refetch on stage-status 409s — `submit()` in the drawer routes every action through `isStaleStageError()` + +**Not done, flagged rather than silently skipped:** +- **No browser verification of any production screen, and no live end-to-end run.** The contract layer is written against a backend whose every endpoint is smoke-verified, the tree type-checks and Turbopack compiles it, but **nothing has been clicked.** Blocked on AuthHex: its configured MySQL host (`187.127.102.190:3306`) is unreachable from this machine, so no token can be issued — which also means the backend smoke suite could not be re-run after this pass's backend additions. +- **`components/Layouts/AppSidebar.tsx:351` still lists `"production"` in `bypassCodes`.** Correct for now — no role is seeded with a `NAV:production` permission, so removing the bypass would hide the section from everyone. Seeding that permission is the real fix (same outstanding item as `procurement`/`hrm`). +- **4 pre-existing `tsc` errors, unrelated to this work — and they block `next build` for the whole app:** `hrm/employees/[id]/page.tsx` (`UpdateEmployeeRequest` missing `hireDate`) and three `hrm/settings/*` pages (an `Api` generic expecting `{value}` where `ApiResult` is returned). None of these files import anything added or changed by this pass, so they were left alone rather than fixed as a side effect of manufacturing work. +- **10 `react-hooks/set-state-in-effect` lint errors across the five production files.** Same rule fires 42 times repo-wide (`app/dashboard/receiving/grn/page.tsx` included); these are the load effects, the hydration-mismatch guards and the builder's stale-upstream repair. No other rule fires in this module. + ## Done diff --git a/Frontend/erp-system/app/dashboard/production/runs/[id]/CustomFieldForm.tsx b/Frontend/erp-system/app/dashboard/production/runs/[id]/CustomFieldForm.tsx new file mode 100644 index 0000000..69a006c --- /dev/null +++ b/Frontend/erp-system/app/dashboard/production/runs/[id]/CustomFieldForm.tsx @@ -0,0 +1,130 @@ +"use client" + +import { FieldDef } from "@/types/production" + +import { Checkbox } from "@/components/ui/checkbox" +import { Field, FieldLabel } from "@/components/ui/field" +import { Input } from "@/components/ui/input" +import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" + +/** + * Runtime renderer for a stage's `fieldDefs` (FR-MFG-07) — the counterpart to the builder's + * field *designer*. The template author picks the types; this turns them into real inputs at + * complete-time and hands back the `fieldValues` object the server stores as jsonb. + * + * Values are keyed by `def.key`, exactly as the server expects, and are never coerced to a + * different shape than the type implies: Number stays a number, Checkbox a boolean, everything + * else a string. That matters because the stored jsonb is later read back verbatim. + */ + +/** + * Labels of required fields with no value yet. + * + * Mirrors the server's `ValidateRequiredFields` exactly, including the part that surprises + * people: an unchecked Checkbox **is** a provided value (`false`), so a required checkbox does + * not force a tick. Only absent, null and whitespace-only strings count as missing — diverging + * here would either block a save the server would accept or let one through it rejects. + */ +export function missingRequiredFields(defs: FieldDef[], values: Record): string[] { + return defs + .filter((def) => { + if (!def.required) return false + const value = values[def.key] + if (value === undefined || value === null) return true + return typeof value === "string" && value.trim() === "" + }) + .map((def) => def.label) +} + +export function CustomFieldForm({ + defs, + values, + onChange, + disabled = false, +}: { + defs: FieldDef[] + values: Record + onChange: (next: Record) => void + disabled?: boolean +}) { + if (defs.length === 0) return null + + function set(key: string, value: unknown) { + onChange({ ...values, [key]: value }) + } + + return ( +
+ {defs.map((def) => { + const value = values[def.key] + const label = ( + + {def.label} + {def.required && *} + + ) + + if (def.type === "Checkbox") { + return ( +
+ set(def.key, checked === true)} + /> + +
+ ) + } + + if (def.type === "Select") { + return ( + + {label} + + value={typeof value === "string" ? value : null} + onValueChange={(v) => set(def.key, v ?? null)} + > + + + + + {(def.options ?? []).map((opt) => ( + + {opt} + + ))} + + + + ) + } + + return ( + + {label} + { + const raw = e.target.value + if (def.type !== "Number") return set(def.key, raw) + // An empty number box means "not answered", not zero — sending 0 would satisfy a + // required check the operator never actually answered. + set(def.key, raw === "" ? null : Number(raw)) + }} + className="h-10 text-sm" + /> + + ) + })} +
+ ) +} diff --git a/Frontend/erp-system/app/dashboard/production/runs/[id]/RunActions.tsx b/Frontend/erp-system/app/dashboard/production/runs/[id]/RunActions.tsx new file mode 100644 index 0000000..e726a9f --- /dev/null +++ b/Frontend/erp-system/app/dashboard/production/runs/[id]/RunActions.tsx @@ -0,0 +1,341 @@ +"use client" + +import { useMemo, useState } from "react" +import { AlertTriangle, Ban, Undo2 } from "lucide-react" + +import { productionRunsApi } from "@/lib/api/production-runs" +import { errorMessage } from "@/lib/error-map" +import { ProductionRunGraph } from "@/types/production" +import { ItemListItem } from "@/types/master-data" +import { ReasonCode } from "@/types/stock" + +import { Button } from "@/components/ui/button" +import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog" +import { Field, FieldLabel } from "@/components/ui/field" +import { Input } from "@/components/ui/input" +import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" + +/** + * Run-level actions (docs/21-FRONTEND-PHASE2.md §5): returning leftover raw material to stock, + * and cancelling the run. Both are hidden once the run leaves InProgress — a completed run's + * costs are closed (`409 RUN_COST_CLOSED`) and a completed run cannot be cancelled + * (`409 RUN_NOT_CANCELLABLE`), so offering either would only produce an error. + */ + +function fmt(n: number): string { + return Number(n.toFixed(4)).toLocaleString(undefined, { maximumFractionDigits: 4 }) +} + +function money(n: number): string { + return n.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 4 }) +} + +interface Returnable { + runInputId: number + stageName: string + itemId: number + /** Base UOM, matching what the return endpoint expects. */ + remaining: number + consumedQty: number + consumedValue: number + returnedQty: number + returnedValue: number +} + +export function RunActions({ + run, + items, + reasonCodes, + onActed, +}: { + run: ProductionRunGraph + items: ItemListItem[] + reasonCodes: ReasonCode[] + onActed: () => void +}) { + const [dialog, setDialog] = useState(null) + const [busy, setBusy] = useState(false) + const [error, setError] = useState(null) + + const [selectedInputId, setSelectedInputId] = useState(null) + const [returnQty, setReturnQty] = useState("") + const [returnReasonId, setReturnReasonId] = useState(null) + + const [cancelReasonId, setCancelReasonId] = useState(null) + const [cancelNote, setCancelNote] = useState("") + + const itemName = useMemo(() => { + const byId = new Map(items.map((i) => [i.itemId, i.name])) + return (id: number) => byId.get(id) ?? `Item #${id}` + }, [items]) + + /** + * Stock inputs with material still unreturned. Upstream inputs are excluded: they carry work + * in progress that never entered stock, so there is nothing to return. + */ + const returnable = useMemo( + () => + run.stages.flatMap((stage) => + stage.inputs + .filter((i) => i.source === "Stock" && i.itemId !== null && i.consumedQty - i.returnedQty > 0) + .map((i) => ({ + runInputId: i.runInputId, + stageName: stage.name, + itemId: i.itemId!, + remaining: i.consumedQty - i.returnedQty, + consumedQty: i.consumedQty, + consumedValue: i.consumedValue, + returnedQty: i.returnedQty, + returnedValue: i.returnedValue, + })) + ), + [run.stages] + ) + + const selected = returnable.find((r) => r.runInputId === selectedInputId) ?? null + const productionReasons = reasonCodes.filter((r) => r.context === "Production") + + // Weighted average cost of what this input actually consumed — the rate the returned stock + // goes back in at, and the same figure the server derives from consumedValue/consumedQty. + const weightedCost = selected && selected.consumedQty > 0 ? selected.consumedValue / selected.consumedQty : null + + function openLeftover() { + setSelectedInputId(returnable[0]?.runInputId ?? null) + setReturnQty("") + setReturnReasonId(null) + setError(null) + setDialog("leftover") + } + + function openCancel() { + setCancelReasonId(null) + setCancelNote("") + setError(null) + setDialog("cancel") + } + + async function submit(action: () => Promise) { + setBusy(true) + setError(null) + try { + await action() + setDialog(null) + onActed() + } catch (err) { + setError(errorMessage(err)) + } finally { + setBusy(false) + } + } + + if (run.status !== "InProgress") return null + + const returnQtyNum = Number(returnQty) + const returnValid = + selected !== null && + returnReasonId !== null && + Number.isFinite(returnQtyNum) && + returnQtyNum > 0 && + returnQtyNum <= selected.remaining + + return ( + <> +
+ + +
+ + {/* ------------------------------------------------------------- leftover */} + !open && setDialog(null)}> + + + Return leftover material + + Puts unused raw material back into stock at the cost it was consumed at, and takes it out of this + run's cost pool. + + + +
+ + Consumed material + value={selectedInputId} onValueChange={(v) => { setSelectedInputId(v); setReturnQty("") }}> + + + + + {returnable.map((r) => ( + + {itemName(r.itemId)} · {r.stageName} · {fmt(r.remaining)} left + + ))} + + + + + {selected && ( +
+
+ Consumed + + {fmt(selected.consumedQty)} · {money(selected.consumedValue)} + +
+
+ Already returned + + {fmt(selected.returnedQty)} · {money(selected.returnedValue)} + +
+
+ Weighted cost + {weightedCost === null ? "—" : money(weightedCost)} +
+
+ )} + + + + Quantity to return + {selected && (base UOM, max {fmt(selected.remaining)})} + + setReturnQty(e.target.value)} + placeholder={selected ? String(selected.remaining) : ""} + /> + + + + Reason + value={returnReasonId} onValueChange={setReturnReasonId}> + + + + + {productionReasons.map((r) => ( + + {r.code} — {r.description} + + ))} + + + + + {error && ( +
+ + {error} +
+ )} +
+ +
+ + +
+ + + + {/* --------------------------------------------------------------- cancel */} + !open && setDialog(null)}> + + + Cancel this run? + + Everything consumed and not yet returned goes back into stock at its consumed cost. Scrapped output is + written off — it never entered stock. This cannot be undone. + + + +
+ {returnable.length > 0 && ( +
+

Will be returned to stock

+ {returnable.map((r) => ( +
+ {itemName(r.itemId)} + {fmt(r.remaining)} +
+ ))} +
+ )} + + + Reason + value={cancelReasonId} onValueChange={setCancelReasonId}> + + + + + {productionReasons.map((r) => ( + + {r.code} — {r.description} + + ))} + + + + + + Note (optional) + setCancelNote(e.target.value)} /> + + + {error && ( +
+ + {error} +
+ )} +
+ +
+ + +
+ + + + ) +} diff --git a/Frontend/erp-system/app/dashboard/production/runs/[id]/StageDrawer.tsx b/Frontend/erp-system/app/dashboard/production/runs/[id]/StageDrawer.tsx new file mode 100644 index 0000000..ba69571 --- /dev/null +++ b/Frontend/erp-system/app/dashboard/production/runs/[id]/StageDrawer.tsx @@ -0,0 +1,739 @@ +"use client" + +import { useEffect, useMemo, useRef, useState } from "react" +import { AlertTriangle, Ban, CheckCircle2, PackageCheck, Play, Send, Undo2 } from "lucide-react" + +import { cn } from "@/lib/utils" +import { isStaleStageError, productionRunsApi } from "@/lib/api/production-runs" +import { errorMessage } from "@/lib/error-map" +import { CustomFieldForm, missingRequiredFields } from "./CustomFieldForm" +import { STAGE_STATUS_COLOR, STAGE_STATUS_LABEL, type StageStatus } from "@/lib/production-status-colors" +import { + CompleteOutputLine, + ProductionRunGraph, + RunStage, + RunStageInput, + RunStageOutput, + StageQuantityLine, + TransferLine, +} from "@/types/production" +import { ItemListItem, Uom } from "@/types/master-data" +import { ReasonCode } from "@/types/stock" + +import { AlertDialog, AlertDialogContent } from "@/components/ui/alert-dialog" +import { Badge } from "@/components/ui/badge" +import { Button } from "@/components/ui/button" +import { Input } from "@/components/ui/input" +import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" +import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from "@/components/ui/sheet" +import { Separator } from "@/components/ui/separator" + +/** + * The stage drawer (docs/21-FRONTEND-PHASE2.md §5) — the only place a run is actually driven. + * + * One component rather than the seven the plan sketched: each per-status panel is ~30 lines and + * they all share the same lookup helpers, submit wrapper, and error handling, so splitting them + * would mean threading that shared context through seven prop lists for no isolation benefit. + * + * The body is switched on `stage.status`, which is deliberately the *server's* status and never + * a local guess — every action re-fetches the whole run through `onActed`, so what is rendered + * is always what the server last said. Two consequences worth knowing: + * + * * A 409 carrying a stage-status code means someone else moved first. `submit` refreshes + * silently instead of showing an error (docs/21 §6); that is also what makes the server's + * accept-and-ignore `Idempotency-Key` posture feel right — a double-click just refreshes. + * * Local form state is keyed off `stage.runStageId` and reset whenever the stage changes, so + * a refresh mid-edit can never post figures from a stage the user is no longer looking at. + */ + +function fmt(n: number): string { + return Number(n.toFixed(4)).toLocaleString(undefined, { maximumFractionDigits: 4 }) +} + +function money(n: number): string { + return n.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 4 }) +} + +/** Minutes between two instants, floored — the same unit the server reports `actualMinutes` in. */ +function minutesSince(iso: string, now: number): number { + return Math.max(0, Math.floor((now - new Date(iso).getTime()) / 60_000)) +} + +function StatusPill({ status }: { status: StageStatus }) { + const color = STAGE_STATUS_COLOR[status] + return ( + + + {STAGE_STATUS_LABEL[status]} + + ) +} + +function Row({ label, children }: { label: string; children: React.ReactNode }) { + return ( +
+ {label} + {children} +
+ ) +} + +export function StageDrawer({ + run, + stage, + items, + uoms, + reasonCodes, + onClose, + onActed, +}: { + run: ProductionRunGraph + stage: RunStage | null + items: ItemListItem[] + uoms: Uom[] + reasonCodes: ReasonCode[] + onClose: () => void + onActed: () => void +}) { + const [busy, setBusy] = useState(false) + const [error, setError] = useState(null) + + // Editable planned quantities (Ready only) keyed by run input/output id. + const [plannedInputs, setPlannedInputs] = useState>({}) + const [plannedOutputs, setPlannedOutputs] = useState>({}) + + // Complete-form state. + const [produced, setProduced] = useState>({}) + const [scrapped, setScrapped] = useState>({}) + const [scrapReason, setScrapReason] = useState>({}) + const [fieldValues, setFieldValues] = useState>({}) + + // Transfer state — the amount to push per output, defaulted to everything available. + const [transferQty, setTransferQty] = useState>({}) + + const [confirm, setConfirm] = useState(null) + + // A per-action Idempotency-Key, minted fresh for each stage the drawer opens on. Same shape as + // app/dashboard/receiving/grn/[id]/page.tsx. + const idempotencyKey = useRef(crypto.randomUUID()) + + const stageId = stage?.runStageId ?? null + + // Reseed every form whenever the drawer switches stage *or* the server sends new figures for + // the one it is on. Without the second half, a refresh after an action would leave the inputs + // showing pre-action numbers. + useEffect(() => { + if (!stage) return + setPlannedInputs(Object.fromEntries(stage.inputs.map((i) => [i.runInputId, String(i.plannedQty)]))) + setPlannedOutputs(Object.fromEntries(stage.outputs.map((o) => [o.runOutputId, String(o.plannedQty)]))) + setProduced(Object.fromEntries(stage.outputs.map((o) => [o.runOutputId, String(o.producedQty || o.plannedQty)]))) + setScrapped(Object.fromEntries(stage.outputs.map((o) => [o.runOutputId, String(o.scrappedQty || 0)]))) + setScrapReason(Object.fromEntries(stage.outputs.map((o) => [o.runOutputId, o.scrapReasonCodeId]))) + setFieldValues((stage.fieldValues ?? {}) as Record) + setTransferQty(Object.fromEntries(stage.outputs.map((o) => [o.runOutputId, String(o.availableToTransfer)]))) + setError(null) + idempotencyKey.current = crypto.randomUUID() + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [stageId, stage?.status, stage?.outputs, stage?.inputs]) + + // Live elapsed while the stage is running (FR-MFG-19). One tick a minute is enough — the + // figure is rendered in whole minutes, so a faster interval would just re-render for nothing. + const [now, setNow] = useState(() => Date.now()) + const running = stage?.actualStartAt != null && stage?.actualEndAt == null + useEffect(() => { + if (!running) return + const timer = setInterval(() => setNow(Date.now()), 60_000) + return () => clearInterval(timer) + }, [running]) + + const itemName = useMemo(() => { + const byId = new Map(items.map((i) => [i.itemId, i.name])) + return (id: number | null) => (id === null ? "—" : byId.get(id) ?? `Item #${id}`) + }, [items]) + + const uomName = useMemo(() => { + const byId = new Map(uoms.map((u) => [u.uomId, u.name])) + return (id: number) => byId.get(id) ?? `#${id}` + }, [uoms]) + + const stageName = useMemo(() => { + const byId = new Map(run.stages.map((s) => [s.runStageId, s.name])) + return (id: number) => byId.get(id) ?? `Stage #${id}` + }, [run.stages]) + + if (!stage) return null + + const isEditable = stage.status === "Ready" + const upstreamInputs = stage.inputs.filter((i) => i.source === "Upstream") + const deliveredSoFar = upstreamInputs.reduce((sum, i) => sum + i.deliveredQty, 0) + const canRejectIntake = (stage.status === "Ready" || stage.status === "Waiting") && deliveredSoFar > 0 + const availableTotal = stage.outputs.reduce((sum, o) => sum + o.availableToTransfer, 0) + const stageEvents = run.events.filter((e) => e.runStageId === stage.runStageId) + + /** + * One wrapper for every action: busy flag, error surfacing, and the docs/21 §6 rule that a + * stage-status 409 refreshes silently rather than shouting at the user. + */ + async function submit(action: () => Promise) { + setBusy(true) + setError(null) + try { + await action() + idempotencyKey.current = crypto.randomUUID() + onActed() + } catch (err) { + if (isStaleStageError(err)) { + onActed() + return + } + setError(errorMessage(err)) + } finally { + setBusy(false) + } + } + + function saveQuantities() { + const inputs: StageQuantityLine[] = stage!.inputs + .map((i) => ({ id: i.runInputId, plannedQty: Number(plannedInputs[i.runInputId] ?? i.plannedQty) })) + .filter((line) => Number.isFinite(line.plannedQty) && line.plannedQty > 0) + const outputs: StageQuantityLine[] = stage!.outputs + .map((o) => ({ id: o.runOutputId, plannedQty: Number(plannedOutputs[o.runOutputId] ?? o.plannedQty) })) + .filter((line) => Number.isFinite(line.plannedQty) && line.plannedQty > 0) + + return submit(() => productionRunsApi.updateStageQuantities(run.runId, stage!.runStageId, { inputs, outputs })) + } + + function completeStage() { + const outputs: CompleteOutputLine[] = stage!.outputs.map((o) => ({ + runOutputId: o.runOutputId, + producedQty: Number(produced[o.runOutputId] ?? 0) || 0, + scrappedQty: Number(scrapped[o.runOutputId] ?? 0) || 0, + scrapReasonCodeId: Number(scrapped[o.runOutputId] ?? 0) > 0 ? scrapReason[o.runOutputId] : null, + })) + + return submit(() => + productionRunsApi.complete( + run.runId, + stage!.runStageId, + { outputs, fieldValues: Object.keys(fieldValues).length > 0 ? fieldValues : null }, + idempotencyKey.current + ) + ) + } + + /** + * Approve. An empty `transfers` array tells the server to push every output in full, which is + * the common case; a line is only sent when the user has dialled it down below what's + * available. On the terminal stage the server ignores transfers entirely and posts the receipt. + */ + function approveStage() { + const transfers: TransferLine[] = stage!.outputs + .filter((o) => { + const wanted = Number(transferQty[o.runOutputId] ?? o.availableToTransfer) + return Number.isFinite(wanted) && wanted !== o.availableToTransfer + }) + .map((o) => ({ runOutputId: o.runOutputId, qty: Number(transferQty[o.runOutputId]) })) + + return submit(() => + productionRunsApi.approve( + run.runId, + stage!.runStageId, + transfers.length > 0 ? { transfers } : {}, + idempotencyKey.current + ) + ) + } + + function transferRemainder(output: RunStageOutput) { + const qty = Number(transferQty[output.runOutputId] ?? 0) + return submit(() => + productionRunsApi.transfer( + run.runId, + stage!.runStageId, + { runOutputId: output.runOutputId, qty }, + idempotencyKey.current + ) + ) + } + + // --- terminal receipt preview --------------------------------------------- + // Mirrors the server's arithmetic (docs/30 §D.3 terminal approve) so the operator sees the + // layer they are about to create *before* creating it. Deliberately recomputed here rather + // than requested: there is no preview endpoint, and every input is already on this page. + const terminalOutput = stage.isTerminal ? stage.outputs[0] : undefined + const goodQty = terminalOutput ? terminalOutput.producedQty - terminalOutput.scrappedQty : 0 + const previewUnitCost = goodQty > 0 ? run.costPool.net / goodQty : null + + const scrapReasons = reasonCodes.filter((r) => r.context === "Production") + + const missingFields = missingRequiredFields(stage.fieldDefs, fieldValues) + const missingScrapReasons = stage.outputs + .filter((o) => Number(scrapped[o.runOutputId] ?? 0) > 0 && !scrapReason[o.runOutputId]) + .map((o) => o.name) + + return ( + <> + !open && onClose()}> + + +
+ {stage.name} + + {stage.roleLabel && ( + + {stage.roleLabel} + + )} + {stage.isTerminal && ( + + Final stage + + )} +
+ + Estimated {stage.estimatedMinutes} min + {stage.actualMinutes !== null + ? ` · actual ${stage.actualMinutes} min` + : running && stage.actualStartAt + ? ` · running for ${minutesSince(stage.actualStartAt, now)} min` + : ""} + + + +
+ {error && ( +
+ + {error} +
+ )} + + {/* ---------------------------------------------------------- inputs */} +
+

Inputs

+ {stage.inputs.length === 0 &&

This stage consumes nothing.

} + {stage.inputs.map((input) => ( + setPlannedInputs((prev) => ({ ...prev, [input.runInputId]: v }))} + itemName={itemName} + uomName={uomName} + /> + ))} +
+ + + + {/* --------------------------------------------------------- outputs */} +
+

Outputs

+ {stage.outputs.map((output) => ( +
+
+

{output.name}

+ {uomName(output.uomId)} +
+ {output.itemId !== null && ( +

Finished good: {itemName(output.itemId)}

+ )} + +
+ {isEditable ? ( + + ) : ( + {fmt(output.plannedQty)} + )} + {output.producedQty > 0 && {fmt(output.producedQty)}} + {output.scrappedQty > 0 && ( + + {fmt(output.scrappedQty)} + + )} + {output.transferredQty > 0 && {fmt(output.transferredQty)}} + {output.availableToTransfer > 0 && ( + + {fmt(output.availableToTransfer)} + + )} +
+
+ ))} +
+ + + + {/* ------------------------------------------------ status-specific */} + {stage.status === "Waiting" && ( +

+ Waiting on upstream deliveries. This stage becomes Ready once every upstream input has received its + planned quantity. +

+ )} + + {stage.status === "Ready" && ( +
+

+ Adjust planned quantities if needed, then start. Starting consumes the stock inputs above FIFO — + quantities are locked from that point on. +

+
+ + +
+
+ )} + + {stage.status === "InProgress" && ( +
+

Record output

+ {stage.outputs.map((output) => { + const scrapQty = Number(scrapped[output.runOutputId] ?? 0) + return ( +
+

{output.name}

+ + + {scrapQty > 0 && ( + + value={scrapReason[output.runOutputId] ?? null} + onValueChange={(v) => setScrapReason((prev) => ({ ...prev, [output.runOutputId]: v }))} + > + + + + + {scrapReasons.map((r) => ( + + {r.code} — {r.description} + + ))} + + + )} +
+ ) + })} + + + + {/* + Blocked client-side as well as server-side. The server's 400 + REQUIRED_FIELD_MISSING rolls the whole transaction back, so letting it through + would cost a round trip and — worse — look to the operator like the completion + half-applied. `missingRequiredFields` deliberately mirrors the server's rule. + */} + {missingScrapReasons.length > 0 && ( +

+ Pick a scrap reason for: {missingScrapReasons.join(", ")}. +

+ )} + {missingFields.length > 0 && ( +

Fill in: {missingFields.join(", ")}.

+ )} + + +
+ )} + + {stage.status === "Done" && !stage.isTerminal && ( +
+

Approve & transfer

+

+ Approving pushes work downstream. Leave the amounts as they are to transfer everything, or lower one to + hold some back — you can transfer the remainder later. +

+ {stage.outputs.map((output) => ( + + ))} + +
+ )} + + {stage.status === "Done" && stage.isTerminal && terminalOutput && ( +
+

Finish the run

+
+ {fmt(goodQty)} {uomName(terminalOutput.uomId)} + {money(run.costPool.consumed)} + −{money(run.costPool.returned)} + + {money(run.costPool.net)} + {previewUnitCost === null ? "—" : money(previewUnitCost)} +
+

+ Approving creates a costed stock layer of {fmt(goodQty)} {itemName(terminalOutput.itemId)} and completes + the run. Its costs close at that point — return any leftover materials first. +

+
+ + +
+
+ )} + + {stage.status === "Approved" && availableTotal > 0 && ( +
+

Transfer remainder

+ {stage.outputs + .filter((o) => o.availableToTransfer > 0) + .map((output) => ( +
+ {output.name} + setTransferQty((prev) => ({ ...prev, [output.runOutputId]: e.target.value }))} + className="h-8 w-24 text-sm" + /> + +
+ ))} +
+ )} + + {stage.status === "Approved" && availableTotal === 0 && ( +

Approved — everything this stage produced has moved on.

+ )} + + {canRejectIntake && ( + <> + +
+

Reject what was delivered

+

+ Sends {fmt(deliveredSoFar)} back to the stage(s) that delivered it and reopens them for correction. + No stock moves — this is work in progress, not inventory. +

+ +
+ + )} + + {/* --------------------------------------------------------- history */} + {stageEvents.length > 0 && ( + <> + +
+

History

+
    + {stageEvents.map((event) => ( +
  1. + +
    + {event.eventType} + + {new Date(event.createdAt).toLocaleString()} + + {event.note && {event.note}} +
    +
    2. + ))} +
+
+ + )} +
+ + + + !open && setConfirm(null)}> + + submit(() => productionRunsApi.rejectIntake(run.runId, stage.runStageId, {}, idempotencyKey.current)) + } + /> + + + !open && setConfirm(null)}> + + submit(() => productionRunsApi.rejectTerminal(run.runId, stage.runStageId, {}, idempotencyKey.current)) + } + /> + + + ) +} + +/** Split out only because the input card has three mutually exclusive quantity presentations. */ +function InputCard({ + input, + editable, + value, + onValueChange, + itemName, + uomName, +}: { + input: RunStageInput + editable: boolean + value: string + onValueChange: (value: string) => void + itemName: (id: number | null) => string + uomName: (id: number) => string +}) { + const isUpstream = input.source === "Upstream" + const short = isUpstream && input.deliveredQty < input.plannedQty + + return ( +
+
+

+ {isUpstream ? "Upstream work in progress" : itemName(input.itemId)} +

+ {uomName(input.uomId)} +
+ +
+ {editable ? ( + + ) : ( + {fmt(input.plannedQty)} + )} + + {isUpstream && ( + + {fmt(input.deliveredQty)} + + )} + + {/* + Consumed/returned figures are in the item's BASE uom, while `plannedQty` above is in the + input's declared uom — an input declared in "box of 12" shows planned 3 and consumed 36. + Labelled explicitly so the two are never read as the same unit. + */} + {input.consumedQty > 0 && ( + <> + + {fmt(input.consumedQty)} · {money(input.consumedValue)} + + {input.returnedQty > 0 && ( + + {fmt(input.returnedQty)} · {money(input.returnedValue)} + + )} + + )} +
+
+ ) +} + +/** Thin wrapper so the drawer body stays readable; the renderer itself lives in its own file. */ +function CustomFields({ + stage, + values, + onChange, +}: { + stage: RunStage + values: Record + onChange: (next: Record) => void +}) { + if (stage.fieldDefs.length === 0) return null + return ( +
+

Checks

+ +
+ ) +} diff --git a/Frontend/erp-system/app/dashboard/production/runs/[id]/page.tsx b/Frontend/erp-system/app/dashboard/production/runs/[id]/page.tsx index 3a72224..081d561 100644 --- a/Frontend/erp-system/app/dashboard/production/runs/[id]/page.tsx +++ b/Frontend/erp-system/app/dashboard/production/runs/[id]/page.tsx @@ -1,16 +1,23 @@ "use client" -import { useEffect, useMemo, useState } from "react" +import { useCallback, useEffect, useMemo, useState } from "react" import { useParams, useRouter } from "next/navigation" -import { ReactFlow, Background, Controls, type Edge, type Node } from "@xyflow/react" +import { ReactFlow, Background, Controls, MiniMap, type Edge, type Node, type NodeMouseHandler } from "@xyflow/react" import "@xyflow/react/dist/style.css" import { useTheme } from "next-themes" -import { ArrowLeft, ChevronRight, RotateCcw } from "lucide-react" +import { ArrowLeft, RotateCcw } from "lucide-react" import { cn } from "@/lib/utils" -import { RunStatus, StageSummary } from "@/types/production" -import { INITIAL_RUNS, buildStagePlan, type RunStagePlanItem } from "@/lib/production-mock-runs" -import { STAGE_STATUS_COLOR, STAGE_STATUS_LABEL, STAGE_STATUS_ORDER } from "@/lib/production-status-colors" +import { productionRunsApi } from "@/lib/api/production-runs" +import { itemsApi } from "@/lib/api/items" +import { uomsApi } from "@/lib/api/uoms" +import { warehousesApi } from "@/lib/api/warehouses" +import { reasonCodesApi } from "@/lib/api/reason-codes" +import { errorMessage } from "@/lib/error-map" +import { ProductionRunGraph, ProductionRunStatus, RunStage, StageSummary } from "@/types/production" +import { ItemListItem, Uom, Warehouse } from "@/types/master-data" +import { ReasonCode } from "@/types/stock" +import { STAGE_STATUS_COLOR } from "@/lib/production-status-colors" import { RunHeaderNodeComponent, RunStageNodeComponent, @@ -22,13 +29,10 @@ import { StageProgressStrip, StageStatusLegend } from "@/components/production/s import { Badge } from "@/components/ui/badge" import { Button } from "@/components/ui/button" import { Skeleton } from "@/components/ui/skeleton" -import { toast } from "@/components/ui/toast" +import { StageDrawer } from "./StageDrawer" +import { RunActions } from "./RunActions" -function todayIso() { - return new Date().toISOString().slice(0, 10) -} - -function runStatusBadgeClass(status: RunStatus) { +function runStatusBadgeClass(status: ProductionRunStatus) { if (status === "Completed") return "bg-success/10 text-success" if (status === "Cancelled") return "bg-destructive/10 text-destructive" return "bg-info/10 text-info" @@ -36,116 +40,168 @@ function runStatusBadgeClass(status: RunStatus) { const nodeTypes = { runHeader: RunHeaderNodeComponent, runStage: RunStageNodeComponent } -const STAGE_START_X = 260 -const STAGE_GAP_X = 220 +/** + * Where the run header box sits relative to the stages. + * + * Stage positions come from the run's own `posX`/`posY` — copied from the template at creation + * (FR-MFG-06), so the canvas matches what was drawn in the builder. The header is placed to the + * left of the leftmost stage rather than at a fixed origin, because those coordinates are + * arbitrary and could otherwise put the header on top of a stage. + */ +const HEADER_GAP_X = 240 + +function buildFlow(run: ProductionRunGraph): { nodes: Node[]; edges: Edge[] } { + const minX = run.stages.length > 0 ? Math.min(...run.stages.map((s) => s.posX)) : 0 + const minY = run.stages.length > 0 ? Math.min(...run.stages.map((s) => s.posY)) : 0 + + const nodes: Node[] = [ + { + id: "header", + type: "runHeader", + position: { x: minX - HEADER_GAP_X, y: minY }, + data: { docNo: run.docNo, templateName: run.templateName, status: run.status } satisfies RunHeaderData, + draggable: false, + }, + ] + + // The stage the operator is expected to act on: the furthest-along actionable one, so a run + // mid-flight highlights the stage in progress rather than the first thing still Waiting. + const actionable = ["InProgress", "Done", "Ready"] as const + const activeId = + run.status === "InProgress" + ? actionable.reduce( + (found, status) => found ?? run.stages.find((s) => s.status === status)?.runStageId ?? null, + null + ) + : null + + for (const stage of run.stages) { + const upstream = stage.inputs.filter((i) => i.source === "Upstream") + nodes.push({ + id: String(stage.runStageId), + type: "runStage", + position: { x: stage.posX, y: stage.posY }, + data: { + name: stage.name, + roleLabel: stage.roleLabel, + state: stage.status, + isTerminal: stage.isTerminal, + isEntry: stage.isEntry, + estimatedMinutes: stage.estimatedMinutes, + actualMinutes: stage.actualMinutes, + actualStartAt: stage.actualStartAt, + intake: + upstream.length === 0 + ? null + : { + delivered: upstream.reduce((sum, i) => sum + i.deliveredQty, 0), + planned: upstream.reduce((sum, i) => sum + i.plannedQty, 0), + }, + availableToTransfer: stage.outputs.reduce((sum, o) => sum + o.availableToTransfer, 0), + isActive: stage.runStageId === activeId, + } satisfies RunStageData, + draggable: false, + }) + } + + const edges: Edge[] = run.edges.map((e) => { + const parent = run.stages.find((s) => s.runStageId === e.parentRunStageId) + return { + id: `e${e.runEdgeId}`, + source: String(e.parentRunStageId), + target: String(e.childRunStageId), + animated: parent?.status === "InProgress", + } + }) + + // Entry stages hang off the run header so the line reads left to right from the run itself. + for (const stage of run.stages.filter((s) => s.isEntry)) { + edges.push({ id: `eh-${stage.runStageId}`, source: "header", target: String(stage.runStageId) }) + } + + return { nodes, edges } +} export default function ProductionRunDetailPage() { const params = useParams<{ id: string }>() const router = useRouter() const { resolvedTheme } = useTheme() const runId = Number(params.id) - const run = useMemo(() => INITIAL_RUNS.find((r) => r.runId === runId) ?? null, [runId]) - // Same hydration-mismatch guard as the other canvas pages (templates/page.tsx, - // templates/[id]/page.tsx): colorMode depends on resolvedTheme, unknown on first paint. + const [run, setRun] = useState(null) + const [loadError, setLoadError] = useState(null) + const [selectedStageId, setSelectedStageId] = useState(null) + + const [items, setItems] = useState([]) + const [uoms, setUoms] = useState([]) + const [warehouses, setWarehouses] = useState([]) + const [reasonCodes, setReasonCodes] = useState([]) + + // Same hydration-mismatch guard as the other canvas pages: colorMode depends on + // resolvedTheme, which is unknown on the server and on the client's first paint. const [mounted, setMounted] = useState(false) useEffect(() => setMounted(true), []) - const [status, setStatus] = useState(run?.status ?? "InProgress") - const [completedAt, setCompletedAt] = useState(run?.completedAt ?? null) - const [stages, setStages] = useState(() => - run ? buildStagePlan(run.templateName, run.stageSummary) : [] - ) + const load = useCallback(() => { + setLoadError(null) + productionRunsApi + .get(runId) + .then(({ data }) => setRun(data)) + .catch((err) => setLoadError(errorMessage(err))) + }, [runId]) - const activeIndex = stages.findIndex((s) => s.state !== "Approved") - - function advanceStage(index: number) { - setStages((prev) => { - const curIdx = STAGE_STATUS_ORDER.indexOf(prev[index].state) - if (curIdx >= STAGE_STATUS_ORDER.length - 1) return prev - const next = [...prev] - next[index] = { ...next[index], state: STAGE_STATUS_ORDER[curIdx + 1] } - return next - }) - } - - // No real backend to push this to — advancing every stage to Approved locally completes - // the run on this page only (the Runs board keeps its own separate seed state). useEffect(() => { - if (stages.length > 0 && stages.every((s) => s.state === "Approved") && status === "InProgress") { - setStatus("Completed") - setCompletedAt(todayIso()) - toast.success("Run completed", run ? `${run.docNo} — all stages approved` : undefined) - } - }, [stages, status, run]) + if (Number.isFinite(runId)) load() + }, [runId, load]) - const progressPercent = stages.length > 0 ? Math.round((stages.filter((s) => s.state === "Approved").length / stages.length) * 100) : 0 - const activeStage = activeIndex >= 0 ? stages[activeIndex] : null - const canGiveProgress = status === "InProgress" && activeStage !== null + useEffect(() => { + Promise.all([ + itemsApi.list({ pageSize: 200 }), + uomsApi.list({ pageSize: 200 }), + warehousesApi.list({ pageSize: 200 }), + reasonCodesApi.list("Production", { pageSize: 100 }), + ]) + .then(([itemRes, uomRes, warehouseRes, reasonRes]) => { + setItems(itemRes.items) + setUoms(uomRes.items) + setWarehouses(warehouseRes.items) + setReasonCodes(reasonRes.items) + }) + .catch(() => { + // Reference data only feeds names and pickers — a failure here degrades labels to ids + // rather than blocking the run, so it deliberately doesn't set loadError. + }) + }, []) - function giveProgress() { - if (activeIndex < 0) return - const stage = stages[activeIndex] - const nextState = STAGE_STATUS_ORDER[STAGE_STATUS_ORDER.indexOf(stage.state) + 1] - advanceStage(activeIndex) - toast.success(`${stage.name} → ${STAGE_STATUS_LABEL[nextState]}`, run?.docNo) - } - - const stageSummary: StageSummary = useMemo( - () => ({ - waiting: stages.filter((s) => s.state === "Waiting").length, - ready: stages.filter((s) => s.state === "Ready").length, - inProgress: stages.filter((s) => s.state === "InProgress").length, - done: stages.filter((s) => s.state === "Done").length, - approved: stages.filter((s) => s.state === "Approved").length, - }), - [stages] + const { nodes, edges } = useMemo( + () => (run ? buildFlow(run) : { nodes: [] as Node[], edges: [] as Edge[] }), + [run] ) - const { nodes, edges } = useMemo(() => { - if (!run) return { nodes: [] as Node[], edges: [] as Edge[] } + const stageSummary: StageSummary = useMemo(() => { + const counts: StageSummary = { waiting: 0, ready: 0, inProgress: 0, done: 0, approved: 0 } + for (const stage of run?.stages ?? []) { + if (stage.status === "Waiting") counts.waiting++ + else if (stage.status === "Ready") counts.ready++ + else if (stage.status === "InProgress") counts.inProgress++ + else if (stage.status === "Done") counts.done++ + else counts.approved++ + } + return counts + }, [run]) - const nodes: Node[] = [ - { - id: "header", - type: "runHeader", - position: { x: 0, y: 0 }, - data: { docNo: run.docNo, templateName: run.templateName, status } satisfies RunHeaderData, - draggable: false, - }, - ] - const edges: Edge[] = [] + const selectedStage: RunStage | null = + run?.stages.find((s) => s.runStageId === selectedStageId) ?? null - stages.forEach((s, i) => { - const id = `stage-${i}` - const isActive = i === activeIndex && status === "InProgress" - nodes.push({ - id, - type: "runStage", - position: { x: STAGE_START_X + i * STAGE_GAP_X, y: -8 }, - data: { - name: s.name, - state: s.state, - isActive, - onAdvance: isActive ? () => advanceStage(i) : undefined, - } satisfies RunStageData, - draggable: false, - }) - edges.push({ - id: `e-${id}`, - source: i === 0 ? "header" : `stage-${i - 1}`, - target: id, - animated: s.state === "InProgress", - }) - }) + const onNodeClick: NodeMouseHandler = useCallback((_, node) => { + if (node.type !== "runStage") return + setSelectedStageId(Number(node.id)) + }, []) - return { nodes, edges } - }, [run, stages, activeIndex, status]) - - if (!run) { + if (loadError) { return (
-

Run not found.

+

{loadError}

- - {run.targetQty.toLocaleString()} {run.uom} · {run.finishedItemName} - + Target {run.targetQty.toLocaleString()} Created {new Date(run.createdAt).toLocaleDateString()} - {completedAt && <> · Completed {new Date(completedAt).toLocaleDateString()}} + {run.completedAt && <> · Completed {new Date(run.completedAt).toLocaleDateString()}}
- +
- {progressPercent}% complete - {activeStage && · Current: {activeStage.name}} + {progressPercent}% approved + + {" "}· cost pool {run.costPool.net.toLocaleString(undefined, { minimumFractionDigits: 2 })} +
@@ -210,10 +284,7 @@ export default function ProductionRunDetailPage() { />
- +
@@ -221,15 +292,18 @@ export default function ProductionRunDetailPage() { -
+

Click a stage to open it.

+ +
{mounted ? ( + ) : ( )}
+ + setSelectedStageId(null)} + onActed={load} + />
) } diff --git a/Frontend/erp-system/app/dashboard/production/runs/page.tsx b/Frontend/erp-system/app/dashboard/production/runs/page.tsx index 3d85b90..0aca54b 100644 --- a/Frontend/erp-system/app/dashboard/production/runs/page.tsx +++ b/Frontend/erp-system/app/dashboard/production/runs/page.tsx @@ -1,13 +1,18 @@ "use client" -import { useMemo, useState } from "react" +import { useCallback, useEffect, useState } from "react" import { useRouter } from "next/navigation" import { ChevronRight, PlayCircle, RotateCcw, Search } from "lucide-react" import { cn } from "@/lib/utils" -import { ProductionRun, RunStatus } from "@/types/production" -import { INITIAL_RUNS, STARTABLE_TEMPLATES, buildStagePlan } from "@/lib/production-mock-runs" -import { STAGE_STATUS_COLOR, STAGE_STATUS_LABEL } from "@/lib/production-status-colors" +import { productionRunsApi } from "@/lib/api/production-runs" +import { productionTemplatesApi } from "@/lib/api/production-templates" +import { warehousesApi } from "@/lib/api/warehouses" +import { errorMessage } from "@/lib/error-map" +import { ProductionRunStatus, ProductionRunSummary, ProductionTemplateSummary } from "@/types/production" +import { Bin, Warehouse } from "@/types/master-data" +import { PaginationMeta } from "@/types/common" +import { STAGE_STATUS_COLOR, STAGE_STATUS_LABEL, STAGE_STATUS_ORDER } from "@/lib/production-status-colors" import { Badge } from "@/components/ui/badge" import { Button } from "@/components/ui/button" @@ -15,101 +20,152 @@ import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, Di import { Field, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field" import { Input } from "@/components/ui/input" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" +import { Skeleton } from "@/components/ui/skeleton" import { toast } from "@/components/ui/toast" import { StageProgressStrip, StageStatusLegend } from "@/components/production/stage-progress-strip" -const TEMPLATE_NAMES = Array.from(new Set(INITIAL_RUNS.map((r) => r.templateName))) -const WAREHOUSE_NAMES = Array.from(new Set(INITIAL_RUNS.map((r) => r.warehouseName))) +const PAGE_SIZE = 25 -function todayIso() { - return new Date().toISOString().slice(0, 10) -} +type StatusFilter = ProductionRunStatus | "All" -type StatusFilter = RunStatus | "All" -type NameFilter = string | "All" - -function runStatusBadgeClass(status: RunStatus) { +function runStatusBadgeClass(status: ProductionRunStatus) { if (status === "Completed") return "bg-success/10 text-success" if (status === "Cancelled") return "bg-destructive/10 text-destructive" return "bg-info/10 text-info" } +const SUMMARY_KEYS = { + Waiting: "waiting", + Ready: "ready", + InProgress: "inProgress", + Done: "done", + Approved: "approved", +} as const + export default function ProductionRunsPage() { const router = useRouter() - const [runs, setRuns] = useState(INITIAL_RUNS) + + // null = still loading (the codebase convention for "no data yet" vs "empty result"). + const [runs, setRuns] = useState(null) + const [pagination, setPagination] = useState(null) + const [loadError, setLoadError] = useState(null) + const [searchInput, setSearchInput] = useState("") + const [query, setQuery] = useState("") const [status, setStatus] = useState("All") - const [template, setTemplate] = useState("All") - const [warehouse, setWarehouse] = useState("All") + const [templateId, setTemplateId] = useState(null) + const [warehouseId, setWarehouseId] = useState(null) + const [page, setPage] = useState(1) + + const [templates, setTemplates] = useState([]) + const [warehouses, setWarehouses] = useState([]) const [open, setOpen] = useState(false) const [startTemplateId, setStartTemplateId] = useState(null) const [targetQty, setTargetQty] = useState("") - const [startWarehouse, setStartWarehouse] = useState(null) - const [outputBin, setOutputBin] = useState("") + const [startWarehouseId, setStartWarehouseId] = useState(null) + const [bins, setBins] = useState([]) + const [outputBinId, setOutputBinId] = useState(null) const [formError, setFormError] = useState("") const [submitting, setSubmitting] = useState(false) - const startTemplate = STARTABLE_TEMPLATES.find((t) => t.templateId === startTemplateId) ?? null + // 300ms debounce, matching app/dashboard/receiving/grn/page.tsx. Resets to page 1 with the + // query so a narrower search can't leave you stranded past the last page. + useEffect(() => { + const timer = setTimeout(() => { + setQuery(searchInput.trim()) + setPage(1) + }, 300) + return () => clearTimeout(timer) + }, [searchInput]) + + const load = useCallback(() => { + setLoadError(null) + productionRunsApi + .list({ + page, + pageSize: PAGE_SIZE, + q: query || undefined, + status: status === "All" ? undefined : status, + templateId: templateId ?? undefined, + warehouseId: warehouseId ?? undefined, + }) + .then((res) => { + setRuns(res.items) + setPagination(res.pagination) + }) + .catch((err) => { + setRuns([]) + setLoadError(errorMessage(err)) + }) + }, [page, query, status, templateId, warehouseId]) + + useEffect(load, [load]) + + // Filter and picker fills. Templates are fetched unfiltered so the *filter* can name an + // Inactive template that still has historical runs; the start dialog narrows to Active + // itself, because FR-MFG-01 only blocks starting new runs (docs/21 §4). + useEffect(() => { + Promise.all([productionTemplatesApi.list({ pageSize: 200 }), warehousesApi.list({ pageSize: 200 })]) + .then(([templateRes, warehouseRes]) => { + setTemplates(templateRes.items) + setWarehouses(warehouseRes.items) + }) + .catch((err) => toast.error("Could not load filters", errorMessage(err))) + }, []) + + // Bins belong to a warehouse, so the list is only meaningful once one is picked. + useEffect(() => { + if (startWarehouseId === null) { + setBins([]) + return + } + warehousesApi + .listBins(startWarehouseId) + .then(setBins) + .catch(() => setBins([])) + }, [startWarehouseId]) + + const startableTemplates = templates.filter((t) => t.status === "Active") + const startTemplate = startableTemplates.find((t) => t.templateId === startTemplateId) ?? null const targetQtyNum = Number(targetQty) - const scaleFactor = startTemplate && targetQtyNum > 0 ? targetQtyNum / startTemplate.nominalBatchQty : null function openStartDialog() { setStartTemplateId(null) setTargetQty("") - setStartWarehouse(null) - setOutputBin("") + setStartWarehouseId(null) + setOutputBinId(null) setFormError("") setOpen(true) } - function handleStartRun() { - if (!startTemplate) { - setFormError("Pick a template.") - return - } - if (!(targetQtyNum > 0)) { - setFormError("Target quantity must be greater than 0.") - return - } - if (!startWarehouse) { - setFormError("Pick a warehouse.") - return - } + async function handleStartRun() { + if (!startTemplate) return setFormError("Pick a template.") + if (!(targetQtyNum > 0)) return setFormError("Target quantity must be greater than 0.") + if (startWarehouseId === null) return setFormError("Pick a warehouse.") + + setFormError("") setSubmitting(true) - const nextId = runs.reduce((max, r) => Math.max(max, r.runId), 0) + 1 - const created: ProductionRun = { - runId: nextId, - docNo: `PRD-2026-${String(nextId).padStart(5, "0")}`, - templateName: startTemplate.name, - targetQty: targetQtyNum, - finishedItemName: startTemplate.finishedItemName, - uom: startTemplate.uom, - warehouseName: startWarehouse, - status: "InProgress", - reworkCount: 0, - createdAt: todayIso(), - completedAt: null, - // Freshly started: nothing done yet, first stage ready, the rest waiting. - stageSummary: { waiting: Math.max(startTemplate.stageCount - 1, 0), ready: 1, inProgress: 0, done: 0, approved: 0 }, + try { + const { data } = await productionRunsApi.create({ + templateId: startTemplate.templateId, + targetQty: targetQtyNum, + warehouseId: startWarehouseId, + outputBinId, + }) + toast.success("Run started", `${data.docNo} — ${data.templateName}`) + setOpen(false) + // Straight to the run: the per-stage quantities the operator may want to adjust before + // starting stage one only exist there (docs/30 §4). + router.push(`/dashboard/production/runs/${data.runId}`) + } catch (err) { + setFormError(errorMessage(err)) + } finally { + setSubmitting(false) } - setRuns((prev) => [...prev, created]) - toast.success("Run started", `${created.docNo} — ${created.templateName}${outputBin ? ` → bin ${outputBin}` : ""}`) - setSubmitting(false) - setOpen(false) } - const filtered = useMemo(() => { - const q = searchInput.trim().toLowerCase() - return runs - .filter((r) => (status === "All" ? true : r.status === status)) - .filter((r) => (template === "All" ? true : r.templateName === template)) - .filter((r) => (warehouse === "All" ? true : r.warehouseName === warehouse)) - .filter((r) => (q ? r.docNo.toLowerCase().includes(q) : true)) - .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()) - }, [runs, searchInput, status, template, warehouse]) - - const hasFilters = searchInput.trim().length > 0 || status !== "All" || template !== "All" || warehouse !== "All" + const hasFilters = query.length > 0 || status !== "All" || templateId !== null || warehouseId !== null return (
@@ -128,56 +184,70 @@ export default function ProductionRunsPage() { Template - value={startTemplateId ?? null} onValueChange={(v) => setStartTemplateId(v)}> + value={startTemplateId} onValueChange={setStartTemplateId}> - + - {STARTABLE_TEMPLATES.map((t) => ( - {t.name} + {startableTemplates.map((t) => ( + + {t.name} · {t.code} + ))} 0)}> - - Target quantity{startTemplate && ({startTemplate.uom}, {startTemplate.finishedItemName})} - + Target quantity setTargetQty(e.target.value)} placeholder="e.g. 200" /> - + Warehouse - value={startWarehouse} onValueChange={setStartWarehouse}> + value={startWarehouseId} onValueChange={(v) => { setStartWarehouseId(v); setOutputBinId(null) }}> - {WAREHOUSE_NAMES.map((n) => ( - {n} + {warehouses.map((w) => ( + + {w.name} · {w.code} + ))} - Output bin (optional) - setOutputBin(e.target.value)} placeholder="e.g. BIN-04" /> + Output bin (optional) + value={outputBinId} onValueChange={setOutputBinId}> + + + + + {bins.map((b) => ( + + {b.code} + {b.binType ? ` · ${b.binType}` : ""} + + ))} + + - {scaleFactor !== null && ( + {startTemplate && targetQtyNum > 0 && (
- Scale factor {scaleFactor.toFixed(2)}× — target {targetQtyNum.toLocaleString()} {startTemplate!.uom} vs - {" "}a nominal batch of {startTemplate!.nominalBatchQty.toLocaleString()} {startTemplate!.uom}. Every stage's inputs/outputs scale by this factor; the authoritative - figures come back once the run is created. + Every stage's planned inputs and outputs are scaled from the template's per-batch figures against + this target. The authoritative numbers come back with the run and stay editable until each stage starts.
)} @@ -206,29 +276,33 @@ export default function ProductionRunsPage() { aria-label="Search runs" />
- value={template} onValueChange={(v) => setTemplate(v ?? "All")}> + + value={templateId} + onValueChange={(v) => { setTemplateId(v); setPage(1) }} + > - All templates - {TEMPLATE_NAMES.map((n) => ( - {n} + {templates.map((t) => ( + {t.name} ))} - value={warehouse} onValueChange={(v) => setWarehouse(v ?? "All")}> + + value={warehouseId} + onValueChange={(v) => { setWarehouseId(v); setPage(1) }} + > - All warehouses - {WAREHOUSE_NAMES.map((n) => ( - {n} + {warehouses.map((w) => ( + {w.name} ))} - value={status} onValueChange={(v) => setStatus(v ?? "All")}> + value={status} onValueChange={(v) => { setStatus(v ?? "All"); setPage(1) }}> @@ -241,11 +315,38 @@ export default function ProductionRunsPage() { + {hasFilters && ( + + )} +
- {filtered.length === 0 ? ( + {loadError && ( +
{loadError}
+ )} + + {runs === null ? ( +
+ + + +
+ ) : runs.length === 0 ? (

@@ -253,64 +354,94 @@ export default function ProductionRunsPage() {

) : ( -
- {filtered.map((r) => ( -
-
-
- - {r.targetQty.toLocaleString()} {r.uom} · {r.finishedItemName} - - - Created {new Date(r.createdAt).toLocaleDateString()} - {r.completedAt && <> · Completed {new Date(r.completedAt).toLocaleDateString()}} - -
- -
- + + ) + })} + - - -
- {buildStagePlan(r.templateName, r.stageSummary).map((s, i) => ( - - - {s.name} - · {STAGE_STATUS_LABEL[s.state]} - - ))} + {pagination && pagination.totalPages > 1 && ( +
+

+ Showing {(pagination.page - 1) * pagination.pageSize + 1}– + {Math.min(pagination.page * pagination.pageSize, pagination.totalItems)} of {pagination.totalItems} +

+
+ +
- - ))} -
+
+ )} + )} ) diff --git a/Frontend/erp-system/app/dashboard/production/templates/[id]/StageEditorPanel.tsx b/Frontend/erp-system/app/dashboard/production/templates/[id]/StageEditorPanel.tsx index 60dc214..825740d 100644 --- a/Frontend/erp-system/app/dashboard/production/templates/[id]/StageEditorPanel.tsx +++ b/Frontend/erp-system/app/dashboard/production/templates/[id]/StageEditorPanel.tsx @@ -3,7 +3,16 @@ import { Plus, Trash2, X } from "lucide-react" import { cn } from "@/lib/utils" -import { FieldDef, FieldType, FormulaInput, FormulaOutput, InputSource, MockItem, StageNodeData } from "./types" +import { CustomFieldType, StageInputSource } from "@/types/production" +import { ItemListItem, Uom } from "@/types/master-data" +import { + BuilderFieldDef, + BuilderInput, + BuilderOutput, + StageNodeData, + newKey, + newLocalId, +} from "./types" import { Button } from "@/components/ui/button" import { Field, FieldLabel } from "@/components/ui/field" @@ -15,65 +24,138 @@ function slugify(label: string) { return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") } -function newId() { - return Math.random().toString(36).slice(2, 10) -} - const ROLE_SUGGESTIONS = ["Assembly", "QA", "Welding", "Packing", "Inspection", "Cutting", "Soldering"] -const FIELD_TYPES: FieldType[] = ["Text", "Number", "Checkbox", "Date", "Select"] +const FIELD_TYPES: CustomFieldType[] = ["Text", "Number", "Checkbox", "Date", "Select"] export interface UpstreamOutputOption { - stageId: string + stageKey: string stageName: string - outputId: string + outputKey: string outputName: string } +/** One row per input/output quantity — UOM select plus qty, used three times below. */ +function QtyRow({ + qty, + uomId, + uoms, + readOnly, + onQtyChange, + onUomChange, +}: { + qty: number + uomId: number | null + uoms: Uom[] + readOnly: boolean + onQtyChange: (qty: number) => void + onUomChange: (uomId: number) => void +}) { + return ( +
+ onQtyChange(Number(e.target.value) || 0)} + className="h-8 text-sm" + placeholder="Qty per batch" + aria-label="Quantity per batch" + /> + value={uomId} onValueChange={(v) => v && onUomChange(v)}> + + + + + {uoms.map((u) => ( + + {u.name} + + ))} + + +
+ ) +} + export function StageEditorPanel({ - nodeId, data, isTerminal, upstreamOptions, items, + uoms, readOnly, onChange, onDelete, onClose, }: { - nodeId: string data: StageNodeData isTerminal: boolean upstreamOptions: UpstreamOutputOption[] - items: MockItem[] + items: ItemListItem[] + uoms: Uom[] readOnly: boolean onChange: (patch: Partial) => void onDelete: () => void onClose: () => void }) { - function updateInput(inputId: string, patch: Partial) { - onChange({ inputs: data.inputs.map((i) => (i.inputId === inputId ? { ...i, ...patch } : i)) }) + function updateInput(localId: string, patch: Partial) { + onChange({ inputs: data.inputs.map((i) => (i.localId === localId ? { ...i, ...patch } : i)) }) } function addInput() { - onChange({ inputs: [...data.inputs, { inputId: newId(), source: "Stock" as InputSource, qty: 1 }] }) + onChange({ + inputs: [ + ...data.inputs, + { localId: newLocalId(), source: "Stock", itemId: null, fromOutputKey: null, uomId: null, qtyPerBatch: 1 }, + ], + }) } - function removeInput(inputId: string) { - onChange({ inputs: data.inputs.filter((i) => i.inputId !== inputId) }) + function removeInput(localId: string) { + onChange({ inputs: data.inputs.filter((i) => i.localId !== localId) }) } - function updateOutput(outputId: string, patch: Partial) { - onChange({ outputs: data.outputs.map((o) => (o.outputId === outputId ? { ...o, ...patch } : o)) }) + /** + * Switching source clears the other side's field. Leaving a stale `itemId` on an Upstream + * input (or a stale `fromOutputKey` on a Stock one) is a 422 GRAPH_INPUT_SOURCE_INVALID — + * the validator rejects an input that carries both. + */ + function changeInputSource(localId: string, source: StageInputSource) { + updateInput(localId, source === "Stock" ? { source, fromOutputKey: null } : { source, itemId: null }) + } + + /** Default the UOM to the item's base unit — right most of the time, still overridable. */ + function pickInputItem(input: BuilderInput, itemId: number) { + const item = items.find((i) => i.itemId === itemId) + updateInput(input.localId, { itemId, uomId: input.uomId ?? item?.baseUomId ?? null }) + } + + function updateOutput(key: string, patch: Partial) { + onChange({ outputs: data.outputs.map((o) => (o.key === key ? { ...o, ...patch } : o)) }) } function addOutput() { - onChange({ outputs: [...data.outputs, { outputId: newId(), name: "", uom: "PCS", qty: 1 }] }) + onChange({ + outputs: [...data.outputs, { key: newKey(), itemId: null, name: "", uomId: null, qtyPerBatch: 1 }], + }) } - function removeOutput(outputId: string) { - onChange({ outputs: data.outputs.filter((o) => o.outputId !== outputId) }) + function removeOutput(key: string) { + onChange({ outputs: data.outputs.filter((o) => o.key !== key) }) } - function updateField(fieldId: string, patch: Partial) { + /** The terminal output's name mirrors the finished item, so the two can't drift apart. */ + function pickOutputItem(output: BuilderOutput, itemId: number) { + const item = items.find((i) => i.itemId === itemId) + updateOutput(output.key, { + itemId, + name: item?.name ?? output.name, + uomId: output.uomId ?? item?.baseUomId ?? null, + }) + } + + function updateField(localId: string, patch: Partial) { onChange({ fieldDefs: data.fieldDefs.map((f) => { - if (f.fieldId !== fieldId) return f + if (f.localId !== localId) return f const next = { ...f, ...patch } if (patch.label !== undefined) next.key = slugify(patch.label) || f.key return next @@ -82,11 +164,14 @@ export function StageEditorPanel({ } function addField() { onChange({ - fieldDefs: [...data.fieldDefs, { fieldId: newId(), key: "", label: "", type: "Text", options: [], required: false }], + fieldDefs: [ + ...data.fieldDefs, + { localId: newLocalId(), key: "", label: "", type: "Text", options: [], required: false }, + ], }) } - function removeField(fieldId: string) { - onChange({ fieldDefs: data.fieldDefs.filter((f) => f.fieldId !== fieldId) }) + function removeField(localId: string) { + onChange({ fieldDefs: data.fieldDefs.filter((f) => f.localId !== localId) }) } return ( @@ -145,13 +230,13 @@ export function StageEditorPanel({
{data.inputs.length === 0 &&

No inputs yet.

} {data.inputs.map((input) => ( -
+
- + value={input.source} - onValueChange={(v) => v && updateInput(input.inputId, { source: v })} + onValueChange={(v) => v && changeInputSource(input.localId, v)} > - + @@ -160,70 +245,56 @@ export function StageEditorPanel({ {!readOnly && ( - )}
- {input.source === "Stock" ? ( -
+
+ {input.source === "Stock" ? ( - value={input.itemId ?? null} - onValueChange={(v) => { - const item = items.find((i) => i.itemId === v) - updateInput(input.inputId, { itemId: v ?? undefined, itemName: item?.name, uom: item?.uom }) - }} + value={input.itemId} + onValueChange={(v) => v && pickInputItem(input, v)} > - + {items.map((i) => ( - {i.name} + + {i.name} · {i.sku} + ))} -
- updateInput(input.inputId, { qty: Number(e.target.value) || 0 })} - className="h-8 text-sm" - placeholder="Qty" - /> - {input.uom ?? "—"} -
- updateInput(input.inputId, { batch: e.target.value })} - className="h-8 text-sm" - placeholder="Batch (optional)" - /> -
- ) : ( - - value={input.upstreamOutputId ?? null} - onValueChange={(v) => { - const opt = upstreamOptions.find((o) => o.outputId === v) - updateInput(input.inputId, { upstreamOutputId: v ?? undefined, upstreamStageId: opt?.stageId }) - }} - > - - - - - {upstreamOptions.map((o) => ( - - {o.stageName} — {o.outputName} - - ))} - - - )} + ) : ( + + value={input.fromOutputKey} + onValueChange={(v) => v && updateInput(input.localId, { fromOutputKey: v })} + > + + + + + {upstreamOptions.map((o) => ( + + {o.stageName} — {o.outputName} + + ))} + + + )} + + updateInput(input.localId, { qtyPerBatch })} + onUomChange={(uomId) => updateInput(input.localId, { uomId })} + /> +
))}
@@ -245,22 +316,18 @@ export function StageEditorPanel({
{data.outputs.length === 0 &&

No outputs yet.

} {data.outputs.map((output) => ( -
+
{isTerminal ? ( - - value={output.itemId ?? null} - onValueChange={(v) => { - const item = items.find((i) => i.itemId === v) - updateOutput(output.outputId, { itemId: v ?? undefined, name: item?.name ?? "", uom: item?.uom ?? output.uom }) - }} - > - + value={output.itemId} onValueChange={(v) => v && pickOutputItem(output, v)}> + {items.map((i) => ( - {i.name} + + {i.name} · {i.sku} + ))} @@ -268,35 +335,25 @@ export function StageEditorPanel({ updateOutput(output.outputId, { name: e.target.value })} - placeholder="Output name" + onChange={(e) => updateOutput(output.key, { name: e.target.value })} + placeholder="Output name (work in progress)" className="h-8 flex-1 text-sm" /> )} {!readOnly && ( - )}
-
- updateOutput(output.outputId, { qty: Number(e.target.value) || 0 })} - className="h-8 text-sm" - placeholder="Qty" - /> - updateOutput(output.outputId, { uom: e.target.value })} - className="h-8 w-20 text-sm" - placeholder="UOM" - /> -
+ updateOutput(output.key, { qtyPerBatch })} + onUomChange={(uomId) => updateOutput(output.key, { uomId })} + />
))}
@@ -316,28 +373,28 @@ export function StageEditorPanel({
{data.fieldDefs.length === 0 &&

No custom fields.

} {data.fieldDefs.map((field) => ( -
+
updateField(field.fieldId, { label: e.target.value })} + onChange={(e) => updateField(field.localId, { label: e.target.value })} placeholder="Label" className="h-8 flex-1 text-sm" /> {!readOnly && ( - )}
{field.key &&

key: {field.key}

}
- + value={field.type} - onValueChange={(v) => v && updateField(field.fieldId, { type: v })} + onValueChange={(v) => v && updateField(field.localId, { type: v })} > - + @@ -351,7 +408,7 @@ export function StageEditorPanel({ size="sm" checked={field.required} disabled={readOnly} - onCheckedChange={(checked) => updateField(field.fieldId, { required: checked })} + onCheckedChange={(checked) => updateField(field.localId, { required: checked })} /> Required
@@ -360,7 +417,7 @@ export function StageEditorPanel({ updateField(field.fieldId, { options: e.target.value.split(",").map((s) => s.trim()).filter(Boolean) })} + onChange={(e) => updateField(field.localId, { options: e.target.value.split(",").map((s) => s.trim()).filter(Boolean) })} placeholder="Options, comma separated" className="mt-2 h-8 text-sm" /> @@ -380,5 +437,3 @@ export function StageEditorPanel({
) } - -export { newId } diff --git a/Frontend/erp-system/app/dashboard/production/templates/[id]/StageNode.tsx b/Frontend/erp-system/app/dashboard/production/templates/[id]/StageNode.tsx index 459defc..4c24214 100644 --- a/Frontend/erp-system/app/dashboard/production/templates/[id]/StageNode.tsx +++ b/Frontend/erp-system/app/dashboard/production/templates/[id]/StageNode.tsx @@ -18,7 +18,9 @@ function StageNode({ data, selected }: NodeProps & { data: StageNodeData }) {
diff --git a/Frontend/erp-system/app/dashboard/production/templates/[id]/page.tsx b/Frontend/erp-system/app/dashboard/production/templates/[id]/page.tsx index 80aee4f..8a19847 100644 --- a/Frontend/erp-system/app/dashboard/production/templates/[id]/page.tsx +++ b/Frontend/erp-system/app/dashboard/production/templates/[id]/page.tsx @@ -1,7 +1,7 @@ "use client" import { useCallback, useEffect, useMemo, useState } from "react" -import { useParams, useSearchParams } from "next/navigation" +import { useParams, useRouter, useSearchParams } from "next/navigation" import Link from "next/link" import { addEdge, @@ -23,45 +23,91 @@ import { useTheme } from "next-themes" import { AlertTriangle, ArrowLeft, Lock, Minus, Plus, Save, Square } from "lucide-react" import { cn } from "@/lib/utils" -import { MOCK_TEMPLATE_INFO } from "@/lib/production-mock-templates" +import { productionTemplatesApi } from "@/lib/api/production-templates" +import { itemsApi } from "@/lib/api/items" +import { uomsApi } from "@/lib/api/uoms" +import { errorMessage } from "@/lib/error-map" +import { CanvasAnnotation, ProductionTemplateGraph, SaveTemplateRequest, TemplateStatus } from "@/types/production" +import { ItemListItem, Uom } from "@/types/master-data" + +import { Badge } from "@/components/ui/badge" import { Button, buttonVariants } from "@/components/ui/button" +import { Field, FieldLabel } from "@/components/ui/field" +import { Input } from "@/components/ui/input" +import { Skeleton } from "@/components/ui/skeleton" import { toast } from "@/components/ui/toast" import StageNode from "./StageNode" import AnnotationBoxNode, { LineNodeComponent } from "./AnnotationNodes" -import { StageEditorPanel, type UpstreamOutputOption, newId } from "./StageEditorPanel" -import { AnnotationData, MockItem, StageNodeData } from "./types" - -const MOCK_ITEMS: MockItem[] = [ - { itemId: 101, name: "Steel Sheet 2mm", uom: "KG" }, - { itemId: 102, name: "Screws M4", uom: "PCS" }, - { itemId: 103, name: "Steel Bracket A", uom: "PCS" }, - { itemId: 104, name: "PCB Board X", uom: "PCS" }, - { itemId: 105, name: "Solder Wire", uom: "M" }, - { itemId: 106, name: "Electronic Component Kit", uom: "SET" }, - { itemId: 107, name: "Wood Plank", uom: "PCS" }, - { itemId: 108, name: "Pallet Standard", uom: "PCS" }, - { itemId: 109, name: "Cable Wire", uom: "M" }, - { itemId: 110, name: "Harness Kit B", uom: "SET" }, -] +import { StageEditorPanel, type UpstreamOutputOption } from "./StageEditorPanel" +import { AnnotationData, StageNodeData, newKey, newLocalId } from "./types" const nodeTypes = { stage: StageNode, box: AnnotationBoxNode, line: LineNodeComponent } -function buildInitialGraph(stageNames: string[]): { nodes: Node[]; edges: Edge[] } { - const nodes: Node[] = stageNames.map((name, i) => ({ - id: `n${i + 1}`, +const DEFAULT_BOX = { width: 320, height: 220 } +const DEFAULT_LINE = { width: 220, height: 4 } + +/** + * Server graph -> React Flow. + * + * A stage's node id **is** its server key, which is why edges need no translation in either + * direction: `edge.source`/`edge.target` are already the `parentKey`/`childKey` the save + * payload wants. Annotations come first in the array because React Flow paints later entries + * on top, and a grouping box belongs behind the stage cards it groups. + */ +function graphToFlow(graph: ProductionTemplateGraph): { nodes: Node[]; edges: Edge[] } { + const annotations: Node[] = graph.annotations.map((a) => ({ + id: `ann-${newLocalId()}`, + type: a.kind, + position: { x: a.posX, y: a.posY }, + width: a.width, + height: a.height, + data: { label: a.label ?? "", rotation: a.rotation ?? undefined } satisfies AnnotationData, + })) + + const stages: Node[] = graph.stages.map((s) => ({ + id: s.key, type: "stage", - position: { x: i * 280 + 40, y: 120 }, - data: { name, roleLabel: "", estimatedMinutes: 15, inputs: [], outputs: [], fieldDefs: [] } satisfies StageNodeData, + position: { x: s.posX, y: s.posY }, + data: { + name: s.name, + roleLabel: s.roleLabel ?? "", + estimatedMinutes: s.estimatedMinutes, + inputs: s.inputs.map((i) => ({ + localId: newLocalId(), + source: i.source, + itemId: i.itemId, + fromOutputKey: i.fromOutputKey, + uomId: i.uomId, + qtyPerBatch: i.qtyPerBatch, + })), + outputs: s.outputs.map((o) => ({ + key: o.key, + itemId: o.itemId, + name: o.name, + uomId: o.uomId, + qtyPerBatch: o.qtyPerBatch, + })), + fieldDefs: s.fieldDefs.map((f) => ({ + localId: newLocalId(), + key: f.key, + label: f.label, + type: f.type, + options: f.options ?? [], + required: f.required, + })), + } satisfies StageNodeData, })) - const edges: Edge[] = stageNames.slice(1).map((_, i) => ({ - id: `e${i + 1}`, - source: `n${i + 1}`, - target: `n${i + 2}`, + + const edges: Edge[] = graph.edges.map((e) => ({ + id: `e${e.edgeId}`, + source: e.parentKey, + target: e.childKey, })) - return { nodes, edges } + + return { nodes: [...annotations, ...stages], edges } } -/** Kahn's algorithm — returns the ids left over (unprocessable) once no more in-degree-0 nodes exist, i.e. the cycle. */ +/** Kahn's algorithm — true when the toposort can't reach every node, i.e. there's a cycle. */ function detectCycle(nodes: Node[], edges: Edge[]): boolean { const inDegree = new Map(nodes.map((n) => [n.id, 0])) for (const e of edges) inDegree.set(e.target, (inDegree.get(e.target) ?? 0) + 1) @@ -79,36 +125,118 @@ function detectCycle(nodes: Node[], edges: Edge[]): boolean { return visited !== nodes.length } +/** + * Best-effort mapping from a `422 GRAPH_*` detail back to the stages it names. + * + * The validator's messages quote real stage names ("...contains a cycle involving: Cut frame, + * Assemble"), so a substring match finds them without the server having to return keys. It is + * deliberately advisory: the full message is always shown in the banner too, so a stage renamed + * to something ambiguous costs a highlight, never the explanation. + */ +function stagesNamedIn(detail: string | undefined, stageNodes: Node[]): Set { + if (!detail) return new Set() + const named = stageNodes.filter((n) => { + const name = (n.data as StageNodeData).name.trim() + return name.length > 0 && detail.includes(name) + }) + return new Set(named.map((n) => n.id)) +} + export default function TemplateBuilderPage() { const params = useParams<{ id: string }>() const searchParams = useSearchParams() + const router = useRouter() const { resolvedTheme } = useTheme() - // A template just created on the list page (see app/dashboard/production/templates/page.tsx - // handleCreate) — no backend exists to look it up by id, so its name/blank graph arrive via - // the URL instead. Every other id falls back to the 5 seeded mock templates. - const isFresh = searchParams.get("fresh") === "1" - const freshName = searchParams.get("name") - const template = isFresh && freshName - ? { name: freshName, activeRunCount: 0, stages: [] as string[] } - : (MOCK_TEMPLATE_INFO[params.id] ?? { name: `Template #${params.id}`, activeRunCount: 0, stages: ["Stage 1"] }) - const locked = template.activeRunCount > 0 + // "new" is a draft that exists only in this page until the first successful Save. A template + // cannot be created from a name alone — the server requires at least one stage and a terminal + // output naming a real finished item (FR-MFG-02/05) — so there is nothing to POST up front. + const isNew = params.id === "new" + const templateId = Number(params.id) - // Deliberately only keyed on the id, not `template.stages` — this is the seed for - // uncontrolled node/edge state below, meant to run once per template, not on every - // in-place edit (which also changes what buildInitialGraph would return via stageNodes). - const initial = useMemo(() => buildInitialGraph(template.stages), [params.id]) // eslint-disable-line react-hooks/exhaustive-deps - const [nodes, setNodes] = useState(initial.nodes) - const [edges, setEdges] = useState(initial.edges) + const [graph, setGraph] = useState(null) + const [etag, setEtag] = useState(null) + const [loadError, setLoadError] = useState(null) + + // Derived rather than its own state: a draft is ready immediately, and a saved template is + // ready as soon as the GET resolves either way. + const loaded = isNew || graph !== null || loadError !== null + + const [code, setCode] = useState("") + const [name, setName] = useState("") + const [description, setDescription] = useState("") + + const [nodes, setNodes] = useState([]) + const [edges, setEdges] = useState([]) const [selectedNodeId, setSelectedNodeId] = useState(null) + const [items, setItems] = useState([]) + const [uoms, setUoms] = useState([]) + + const [saving, setSaving] = useState(false) + const [saveError, setSaveError] = useState(null) + const [conflict, setConflict] = useState(false) + const [lockedByServer, setLockedByServer] = useState(false) + const [focusedKeys, setFocusedKeys] = useState>(new Set()) + const [togglingStatus, setTogglingStatus] = useState(false) + + // `lockedByServer` covers the edit-lock TOCTOU: a run can start between our GET and our PUT, + // in which case the 409 is the first we hear of it (FR-MFG-06). + const activeRunCount = graph?.activeRunCount ?? 0 + const locked = activeRunCount > 0 || lockedByServer + // `resolvedTheme` is unknown on the server (and on the client's first paint, before - // next-themes reads localStorage), so `colorMode` below would differ between the SSR - // markup and the client's first render — same hydration-mismatch class theme-toggle.tsx - // already guards against. Render the canvas only once mounted. + // next-themes reads localStorage), so `colorMode` would differ between the SSR markup and the + // first client render — the same hydration-mismatch class theme-toggle.tsx guards against. const [mounted, setMounted] = useState(false) useEffect(() => setMounted(true), []) + const applyGraph = useCallback((data: ProductionTemplateGraph, tag: string | null) => { + const flow = graphToFlow(data) + setGraph(data) + setEtag(tag) + setCode(data.code) + setName(data.name) + setDescription(data.description ?? "") + setNodes(flow.nodes) + setEdges(flow.edges) + setSelectedNodeId(null) + setConflict(false) + setLockedByServer(false) + setFocusedKeys(new Set()) + setSaveError(null) + }, []) + + const load = useCallback(() => { + setLoadError(null) + productionTemplatesApi + .get(templateId) + .then(({ data, etag: tag }) => applyGraph(data, tag)) + .catch((err) => setLoadError(errorMessage(err))) + }, [templateId, applyGraph]) + + useEffect(() => { + if (isNew) { + // Seeded from the overview's "New Template" dialog. + setCode(searchParams.get("code") ?? "") + setName(searchParams.get("name") ?? "") + return + } + if (Number.isFinite(templateId)) load() + // searchParams is read once for the draft seed; re-running on every query change would + // overwrite what the user has typed since. + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [isNew, templateId, load]) + + useEffect(() => { + Promise.all([itemsApi.list({ pageSize: 200, status: "Active" }), uomsApi.list({ pageSize: 200 })]) + .then(([itemRes, uomRes]) => { + setItems(itemRes.items) + setUoms(uomRes.items) + }) + .catch((err) => toast.error("Could not load items and UOMs", errorMessage(err))) + }, []) + const onNodesChange = useCallback( (changes: NodeChange[]) => setNodes((nds) => applyNodeChanges(changes, nds)), [] @@ -138,18 +266,16 @@ export default function TemplateBuilderPage() { const onPaneClick = useCallback(() => setSelectedNodeId(null), []) // Guarded here, not just by hiding the toolbar/panel controls: `elementsSelectable` stays - // true even when locked (so a locked template can still be inspected), and these two - // setters go straight to setNodes/setEdges — they don't route through onNodesChange, which - // is what actually gets set to `undefined` when locked. Without this check, a locked - // template's box/line labels, rotation, and now the inline delete buttons would all still - // be editable via those paths. + // true even when locked (so a locked template can still be inspected), and these two setters + // go straight to setNodes/setEdges — they don't route through onNodesChange, which is what + // actually gets set to `undefined` when locked. function updateNodeData(nodeId: string, patch: Partial | Partial) { if (locked) return setNodes((nds) => nds.map((n) => (n.id === nodeId ? { ...n, data: { ...n.data, ...patch } } : n))) } function addStage() { - const id = `n${newId()}` + const id = newKey() const existingStages = nodes.filter((n) => n.type === "stage") const maxX = existingStages.reduce((max, n) => Math.max(max, n.position.x), 0) const y = existingStages.length > 0 ? existingStages[existingStages.length - 1].position.y : 120 @@ -159,15 +285,22 @@ export default function TemplateBuilderPage() { id, type: "stage", position: { x: existingStages.length > 0 ? maxX + 280 : 40, y }, - data: { name: "New stage", roleLabel: "", estimatedMinutes: 15, inputs: [], outputs: [], fieldDefs: [] } satisfies StageNodeData, + data: { + name: "New stage", + roleLabel: "", + estimatedMinutes: 15, + inputs: [], + outputs: [], + fieldDefs: [], + } satisfies StageNodeData, }, ]) setSelectedNodeId(id) } - // Generic across every node type — stage cards, boxes, lines all use this (inline × buttons - // on the nodes themselves, plus the stage editor panel's "Delete stage" button). Box/line - // nodes never have edges, so the edge-filter is a no-op for them, not a special case. + // Generic across every node type — stage cards, boxes and lines all use this (the inline × + // buttons on the nodes themselves, plus the stage editor's "Delete stage"). Box/line nodes + // never have edges, so the edge filter is a no-op for them, not a special case. function deleteNode(nodeId: string) { if (locked) return setNodes((nds) => nds.filter((n) => n.id !== nodeId)) @@ -175,30 +308,14 @@ export default function TemplateBuilderPage() { setSelectedNodeId((id) => (id === nodeId ? null : id)) } - // Boxes/lines are prepended (not appended) so React Flow — which paints later array - // entries on top — renders them behind the stage nodes. - function addBox() { + function addAnnotation(kind: "box" | "line") { + const size = kind === "box" ? DEFAULT_BOX : DEFAULT_LINE setNodes((nds) => [ { - id: `a${newId()}`, - type: "box", - position: { x: 40, y: 40 }, - width: 320, - height: 220, - data: { label: "" } satisfies AnnotationData, - }, - ...nds, - ]) - } - - function addLine() { - setNodes((nds) => [ - { - id: `a${newId()}`, - type: "line", - position: { x: 60, y: 300 }, - width: 220, - height: 4, + id: `ann-${newLocalId()}`, + type: kind, + position: kind === "box" ? { x: 40, y: 40 } : { x: 60, y: 300 }, + ...size, data: { label: "" } satisfies AnnotationData, }, ...nds, @@ -207,15 +324,14 @@ export default function TemplateBuilderPage() { // React Flow's built-in keyboard delete (Backspace/Delete on a selected node) goes through // this callback, not through deleteNode() above — stage edges need cleaning up either way. - // Box/line nodes never have edges, so this is a no-op for them. const onNodesDelete = useCallback((deleted: Node[]) => { const deletedIds = new Set(deleted.map((n) => n.id)) setEdges((eds) => eds.filter((e) => !deletedIds.has(e.source) && !deletedIds.has(e.target))) }, []) - // Boxes/lines are pure annotations — never part of the stage graph, so every graph check - // below operates on stage nodes only (docs/21-FRONTEND-PHASE2.md §2 "Client-side graph - // checks (UX only — server re-validates on save)"). + // Boxes and lines are pure annotations — never part of the stage graph, so every graph check + // below operates on stage nodes only (docs/21 §2 "Client-side graph checks (UX only — server + // re-validates on save)"). const stageNodes = useMemo(() => nodes.filter((n) => n.type === "stage"), [nodes]) const analysis = useMemo(() => { @@ -230,20 +346,33 @@ export default function TemplateBuilderPage() { return { terminalIds, entryIds, disconnectedIds, hasCycle } }, [stageNodes, edges]) - // Clear stale Upstream references after an edge is deleted, with a warning toast — per + /** Output keys a stage may legally draw from — its *direct* parents' outputs (FR-MFG-04). */ + const allowedUpstreamKeys = useCallback( + (stageId: string) => { + const parentIds = new Set(edges.filter((e) => e.target === stageId).map((e) => e.source)) + return new Set( + nodes + .filter((n) => n.type === "stage" && parentIds.has(n.id)) + .flatMap((n) => (n.data as StageNodeData).outputs.map((o) => o.key)) + ) + }, + [edges, nodes] + ) + + // Clear stale Upstream references after an edge is deleted, with a warning toast — docs/21 §2 // "re-check after edge deletions and clear broken references with a warning toast". useEffect(() => { for (const node of stageNodes) { const data = node.data as StageNodeData - const directParentIds = new Set(edges.filter((e) => e.target === node.id).map((e) => e.source)) - const stale = data.inputs.filter((i) => i.source === "Upstream" && i.upstreamStageId && !directParentIds.has(i.upstreamStageId)) + const allowed = allowedUpstreamKeys(node.id) + const stale = data.inputs.filter( + (i) => i.source === "Upstream" && i.fromOutputKey && !allowed.has(i.fromOutputKey) + ) if (stale.length > 0) { updateNodeData(node.id, { - inputs: data.inputs.map((i) => - stale.includes(i) ? { ...i, upstreamStageId: undefined, upstreamOutputId: undefined } : i - ), + inputs: data.inputs.map((i) => (stale.includes(i) ? { ...i, fromOutputKey: null } : i)), }) - toast.warning("Input reference cleared", `"${data.name}" referenced a stage that's no longer connected.`) + toast.warning("Input reference cleared", `"${data.name}" drew from a stage that no longer feeds it.`) } } // Only re-run when the edge set changes — re-running on every node data edit would loop. @@ -252,28 +381,61 @@ export default function TemplateBuilderPage() { const issues = useMemo(() => { const list: string[] = [] + if (!code.trim()) list.push("Code is required.") + if (!name.trim()) list.push("Name is required.") + if (stageNodes.length === 0) list.push("Add at least one stage.") + if (analysis.hasCycle) list.push("Cycle detected — stages must form a one-directional flow.") - if (analysis.terminalIds.size !== 1) { + if (stageNodes.length > 0 && analysis.terminalIds.size !== 1) { list.push( analysis.terminalIds.size === 0 ? "No terminal stage — connect stages so the line converges to a single final stage." : `${analysis.terminalIds.size} terminal stages found — connect stages so the line converges to a single final stage.` ) } - if (analysis.entryIds.size === 0) list.push("No entry stage — at least one stage must have no inputs from other stages.") + if (stageNodes.length > 0 && analysis.entryIds.size === 0) { + list.push("No entry stage — at least one stage must have no inputs from other stages.") + } if (analysis.disconnectedIds.size > 0) { const names = stageNodes.filter((n) => analysis.disconnectedIds.has(n.id)).map((n) => (n.data as StageNodeData).name) list.push(`Disconnected stage${names.length > 1 ? "s" : ""}: ${names.join(", ")}.`) } + + // Field-completeness. These mirror the server's own requirements, and they are what make + // the non-null assertions in buildRequest() below sound — a row is never sent half-filled. for (const node of stageNodes) { - if (!analysis.terminalIds.has(node.id)) continue const data = node.data as StageNodeData - if (data.outputs.length === 0 || data.outputs.some((o) => !o.itemId)) { - list.push(`Terminal stage "${data.name}" needs an output with a finished-good item picked.`) + const label = data.name.trim() || "Untitled stage" + const isTerminal = analysis.terminalIds.has(node.id) + + if (!data.name.trim()) list.push("Every stage needs a name.") + + data.inputs.forEach((input, i) => { + const where = `Input ${i + 1} of "${label}"` + if (input.source === "Stock" && input.itemId === null) list.push(`${where} needs an item.`) + if (input.source === "Upstream" && !input.fromOutputKey) list.push(`${where} needs an upstream output.`) + if (input.uomId === null) list.push(`${where} needs a UOM.`) + if (input.qtyPerBatch <= 0) list.push(`${where} needs a quantity greater than zero.`) + }) + + data.outputs.forEach((output, i) => { + const where = `Output ${i + 1} of "${label}"` + if (!isTerminal && !output.name.trim()) list.push(`${where} needs a name.`) + if (output.uomId === null) list.push(`${where} needs a UOM.`) + if (output.qtyPerBatch <= 0) list.push(`${where} needs a quantity greater than zero.`) + }) + + if (isTerminal) { + if (data.outputs.length !== 1) { + list.push(`Terminal stage "${label}" must have exactly one output (the finished good).`) + } else if (data.outputs[0].itemId === null) { + list.push(`Terminal stage "${label}" needs its output linked to a finished-good item.`) + } } } + return list - }, [analysis, stageNodes]) + }, [analysis, stageNodes, code, name]) const selectedNode = stageNodes.find((n) => n.id === selectedNodeId) const upstreamOptions: UpstreamOutputOption[] = useMemo(() => { @@ -284,9 +446,9 @@ export default function TemplateBuilderPage() { if (!parent) return [] const parentData = parent.data as StageNodeData return parentData.outputs.map((o) => ({ - stageId: parent.id, + stageKey: parent.id, stageName: parentData.name, - outputId: o.outputId, + outputKey: o.key, outputName: o.name || "(unnamed output)", })) }) @@ -301,6 +463,7 @@ export default function TemplateBuilderPage() { data: { ...n.data, disconnected: analysis.disconnectedIds.has(n.id), + focused: focusedKeys.has(n.id), onDelete: locked ? undefined : () => deleteNode(n.id), }, } @@ -314,16 +477,166 @@ export default function TemplateBuilderPage() { }, } ), - [nodes, analysis.disconnectedIds] // eslint-disable-line react-hooks/exhaustive-deps + [nodes, analysis.disconnectedIds, focusedKeys] // eslint-disable-line react-hooks/exhaustive-deps ) - function handleSave() { + function buildRequest(): SaveTemplateRequest { + const stages = stageNodes.map((n) => { + const data = n.data as StageNodeData + const isTerminal = analysis.terminalIds.has(n.id) + return { + key: n.id, + name: data.name.trim(), + roleLabel: data.roleLabel.trim() || null, + estimatedMinutes: data.estimatedMinutes, + posX: Math.round(n.position.x), + posY: Math.round(n.position.y), + fieldDefs: data.fieldDefs.map((f) => ({ + key: f.key, + label: f.label, + type: f.type, + options: f.type === "Select" ? f.options : null, + required: f.required, + })), + inputs: data.inputs.map((i) => ({ + source: i.source, + itemId: i.source === "Stock" ? i.itemId : null, + fromOutputKey: i.source === "Upstream" ? i.fromOutputKey : null, + uomId: i.uomId!, + qtyPerBatch: i.qtyPerBatch, + })), + // Only the terminal stage's output may name an item (FR-MFG-05). A stage that *was* + // terminal and then got a child keeps its picked itemId in local state with the item + // field no longer rendered, so dropping it here is the only way the user can recover — + // an issue-list message about an invisible field would be unactionable. + outputs: data.outputs.map((o) => ({ + key: o.key, + itemId: isTerminal ? o.itemId : null, + name: o.name.trim(), + uomId: o.uomId!, + qtyPerBatch: o.qtyPerBatch, + })), + } + }) + + const annotations: CanvasAnnotation[] = nodes + .filter((n) => n.type === "box" || n.type === "line") + .map((n) => { + const data = n.data as AnnotationData + const fallback = n.type === "box" ? DEFAULT_BOX : DEFAULT_LINE + return { + kind: n.type as "box" | "line", + posX: Math.round(n.position.x), + posY: Math.round(n.position.y), + // `width`/`height` are set on creation and updated by NodeResizer; `measured` is what + // React Flow fills in after layout for nodes sized purely by CSS. + width: Math.round(n.width ?? n.measured?.width ?? fallback.width), + height: Math.round(n.height ?? n.measured?.height ?? fallback.height), + label: data.label.trim() || null, + rotation: data.rotation ?? null, + } + }) + + return { + code: code.trim(), + name: name.trim(), + description: description.trim() || null, + stages, + edges: edges.map((e) => ({ parentKey: e.source, childKey: e.target })), + annotations, + } + } + + async function handleSave() { if (issues.length > 0) { toast.error("Can't save yet", `${issues.length} issue${issues.length > 1 ? "s" : ""} to fix first.`) return } - // No backend contract exists yet (docs/21-FRONTEND-PHASE2.md) — this is a UI-only stub. - toast.success("Template saved", `${template.name} — ${stageNodes.length} stage${stageNodes.length === 1 ? "" : "s"}.`) + + setSaving(true) + setSaveError(null) + setFocusedKeys(new Set()) + + try { + if (isNew) { + const result = await productionTemplatesApi.create(buildRequest()) + toast.success("Template created", `${result.data.code} — ${result.data.name}`) + // Swap the draft URL for the real one. The load effect re-runs on the new id and + // rehydrates from the server, so keys minted here are replaced by real ones. + router.replace(`/dashboard/production/templates/${result.data.templateId}`) + return + } + + if (!etag) return + const result = await productionTemplatesApi.update(templateId, buildRequest(), etag) + applyGraph(result.data, result.etag) + toast.success("Template saved", `${result.data.code} — ${result.data.stages.length} stage(s)`) + } catch (err) { + const errorCode = (err as { code?: string })?.code + const detail = (err as { detail?: string })?.detail + + if (errorCode === "CONCURRENCY_CONFLICT" || errorCode === "PRECONDITION_REQUIRED") { + setConflict(true) + setSaveError(errorMessage(err)) + return + } + if (errorCode === "TEMPLATE_IN_USE") { + // A run started between our GET and this PUT. Lock the canvas rather than reloading, + // so nothing the user just drew is thrown away without them seeing why. + setLockedByServer(true) + setSaveError(errorMessage(err)) + return + } + if (errorCode?.startsWith("GRAPH_") || errorCode === "TERMINAL_OUTPUT_ITEM_REQUIRED") { + setFocusedKeys(stagesNamedIn(detail, stageNodes)) + } + setSaveError(errorMessage(err)) + toast.error("Could not save template", errorMessage(err)) + } finally { + setSaving(false) + } + } + + async function handleToggleStatus() { + if (!graph) return + const next: TemplateStatus = graph.status === "Active" ? "Inactive" : "Active" + setTogglingStatus(true) + try { + await productionTemplatesApi.updateStatus(templateId, next) + // PATCH /status bumps the row's xmin, which invalidates the ETag we hold. Re-read it (and + // only it) so an unsaved canvas edit can still be saved afterwards — a full reload here + // would silently discard the user's work. + const refreshed = await productionTemplatesApi.get(templateId) + setEtag(refreshed.etag) + setGraph((g) => + g ? { ...g, status: refreshed.data.status, activeRunCount: refreshed.data.activeRunCount } : g + ) + toast.success(next === "Active" ? "Template activated" : "Template deactivated") + } catch (err) { + toast.error("Could not update status", errorMessage(err)) + } finally { + setTogglingStatus(false) + } + } + + if (!loaded) { + return ( +
+ + +
+ ) + } + + if (loadError) { + return ( +
+
{loadError}
+ + Back to templates + +
+ ) } return ( @@ -334,47 +647,118 @@ export default function TemplateBuilderPage() {
-

{template.name}

-

{stageNodes.length} stage{stageNodes.length === 1 ? "" : "s"} · {edges.length} connection{edges.length === 1 ? "" : "s"}

+
+

{name || "Untitled template"}

+ {graph ? ( + + {graph.status} + + ) : ( + + Unsaved draft + + )} +
+

+ {stageNodes.length} stage{stageNodes.length === 1 ? "" : "s"} · {edges.length} connection + {edges.length === 1 ? "" : "s"} +

-
+
{!locked && ( - + + + + )} + {graph && ( + )} {!locked && ( - - )} - {!locked && ( - - )} - {!locked && ( - )}
+
+ + Code + setCode(e.target.value)} placeholder="PT-CHAIR" className="h-10" /> + + + Name + setName(e.target.value)} placeholder="Aluminium Frame Assembly" className="h-10" /> + + + Description + setDescription(e.target.value)} + placeholder="Optional" + className="h-10" + /> + +
+ {locked && (
- Template locked — {template.activeRunCount} run{template.activeRunCount === 1 ? "" : "s"} in progress. + {activeRunCount > 0 + ? `Template locked — ${activeRunCount} run${activeRunCount === 1 ? "" : "s"} in progress. It can be viewed but not edited until they finish.` + : "Template locked — a run started while you were editing, so this template can no longer be changed."} +
+ )} + + {conflict && ( +
+ +
+ {saveError ?? "This template was changed by someone else."} Reload before retrying. + +
+
+ )} + + {saveError && !conflict && ( +
+ + {saveError}
)} {issues.length > 0 && ( -
+
{issues.map((issue, i) => (
@@ -412,11 +796,11 @@ export default function TemplateBuilderPage() { {selectedNode && ( updateNodeData(selectedNode.id, patch)} onDelete={() => deleteNode(selectedNode.id)} diff --git a/Frontend/erp-system/app/dashboard/production/templates/[id]/types.ts b/Frontend/erp-system/app/dashboard/production/templates/[id]/types.ts index 29b5f1e..3825fab 100644 --- a/Frontend/erp-system/app/dashboard/production/templates/[id]/types.ts +++ b/Frontend/erp-system/app/dashboard/production/templates/[id]/types.ts @@ -1,73 +1,87 @@ -// Canvas builder types (docs/21-FRONTEND-PHASE2.md §2). Frontend-only shapes — no -// Dtos/Production backend contract exists yet; these mirror the doc's described jsonb -// shapes closely enough to swap in real API types later without touching the canvas/panel. +// Canvas builder state (docs/21-FRONTEND-PHASE2.md §2), shaped for editing rather than for +// the wire. `page.tsx` converts between these and the real contract in `types/production.ts`. +// +// Two things the API shapes can't express and the canvas needs: +// +// * **Stable React list keys.** Stage inputs and custom fields have no client-facing key in +// the contract (only outputs do, because Upstream inputs reference them by key). Rendering +// them by array index would make React reuse the wrong when a row is removed, so +// every editable row carries a throwaway `localId` that is stripped on save. +// * **Half-filled rows.** `uomId` is `number | null` here but `number` on the wire: a row the +// user just added has nothing picked yet. `page.tsx` blocks the save until every one is set, +// which is what makes the non-null assertions in its payload builder sound. +// +// A stage's identity IS its React Flow node id, which is its server key — the stringified +// stage id, or `tmp-` for a stage drawn in this session. That is why edges need no +// translation on save: `edge.source`/`edge.target` are already `parentKey`/`childKey`. -export type FieldType = "Text" | "Number" | "Checkbox" | "Date" | "Select" +import { CustomFieldType, StageInputSource } from "@/types/production" -export interface FieldDef { - fieldId: string +/** `tmp-` prefixed so the server can tell a newly drawn stage/output from one it already has. */ +export function newKey(): string { + return `tmp-${crypto.randomUUID()}` +} + +/** Render-only identity for rows the contract keys by position. Never sent. */ +export function newLocalId(): string { + return crypto.randomUUID() +} + +export interface BuilderInput { + localId: string + source: StageInputSource + /** Stock inputs only. */ + itemId: number | null + /** Upstream inputs only — an output key belonging to a *direct* parent stage. */ + fromOutputKey: string | null + uomId: number | null + qtyPerBatch: number +} + +export interface BuilderOutput { + /** Server output id as a string, or `tmp-`. Upstream inputs reference this. */ + key: string + /** Terminal stage only — the finished good. Must stay null on WIP outputs (FR-MFG-05). */ + itemId: number | null + name: string + uomId: number | null + qtyPerBatch: number +} + +export interface BuilderFieldDef { + localId: string + /** Slugified from `label`; the run's `fieldValues` are keyed by it (FR-MFG-07). */ key: string label: string - type: FieldType - /** Only meaningful when type === "Select". */ + type: CustomFieldType + /** Only sent when `type` is `Select`. */ options: string[] required: boolean } -export type InputSource = "Stock" | "Upstream" - -export interface FormulaInput { - inputId: string - source: InputSource - // Stock source: - itemId?: number - itemName?: string - uom?: string - qty?: number - batch?: string - // Upstream source — references a direct parent stage's output: - upstreamStageId?: string - upstreamOutputId?: string -} - -export interface FormulaOutput { - outputId: string - /** Free text for a non-terminal stage; on the terminal stage this mirrors the picked item's name. */ - name: string - uom: string - qty: number - batch?: string - /** Required once this output sits on the terminal stage (finished good). */ - itemId?: number -} - export interface StageNodeData extends Record { name: string roleLabel: string estimatedMinutes: number - inputs: FormulaInput[] - outputs: FormulaOutput[] - fieldDefs: FieldDef[] - /** Computed by the page on every graph change, not user-editable — no in/out edges at all. */ + inputs: BuilderInput[] + outputs: BuilderOutput[] + fieldDefs: BuilderFieldDef[] + /** Recomputed by the page on every graph change, not user-editable — no in/out edges at all. */ disconnected?: boolean + /** Set when a server `422 GRAPH_*` named this stage, so the canvas can point at it. */ + focused?: boolean /** Injected by the page at render time — deletes this node (and any edges touching it). */ onDelete?: () => void } -export interface MockItem { - itemId: number - name: string - uom: string -} - /** - * Free-floating annotations — grouping boxes and divider lines. Purely visual: they carry - * no graph semantics (no ports, never appear in cycle/terminal/entry/disconnected checks - * or the save-blocking issue list), unlike "stage" nodes. + * Free-floating annotations — grouping boxes and divider lines. Purely visual: they carry no + * graph semantics (no ports, never part of the cycle/terminal/entry/disconnected checks or the + * save-blocking issue list), unlike "stage" nodes. Persisted verbatim in the template's + * `annotations` jsonb so a layout survives a reload. */ export interface AnnotationData extends Record { label: string - /** Degrees, applied as a CSS rotation around the node's own center. Lines only (§ AnnotationNodes). */ + /** Degrees, applied as a CSS rotation around the node's own center. Lines only. */ rotation?: number } - diff --git a/Frontend/erp-system/app/dashboard/production/templates/page.tsx b/Frontend/erp-system/app/dashboard/production/templates/page.tsx index c4e6db0..6febe70 100644 --- a/Frontend/erp-system/app/dashboard/production/templates/page.tsx +++ b/Frontend/erp-system/app/dashboard/production/templates/page.tsx @@ -1,14 +1,16 @@ "use client" -import { useEffect, useMemo, useState } from "react" +import { useCallback, useEffect, useMemo, useState } from "react" import { useRouter } from "next/navigation" import { ReactFlow, Background, Controls, type Edge, type Node, type NodeMouseHandler } from "@xyflow/react" import "@xyflow/react/dist/style.css" import { useTheme } from "next-themes" import { LayoutTemplate, Plus, Search } from "lucide-react" -import { MOCK_TEMPLATE_INFO } from "@/lib/production-mock-templates" -import { ProductionTemplate, TemplateStatus } from "@/types/production" +import { productionTemplatesApi } from "@/lib/api/production-templates" +import { errorMessage } from "@/lib/error-map" +import { ProductionTemplateSummary, TemplateStatus } from "@/types/production" +import { PaginationMeta } from "@/types/common" import { LineHeaderNodeComponent, LineStageNodeComponent, @@ -22,22 +24,10 @@ import { Field, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field import { Input } from "@/components/ui/input" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Skeleton } from "@/components/ui/skeleton" -import { toast } from "@/components/ui/toast" - -// Frontend-only mock data — no Dtos/Production backend exists yet (docs/21-FRONTEND-PHASE2.md). -const INITIAL_TEMPLATES: ProductionTemplate[] = [ - { templateId: 1, docNo: "TPL-1001", name: "Steel Bracket Assembly", status: "Active", stageCount: 3, activeRunCount: 2, updatedAt: "2026-07-20" }, - { templateId: 2, docNo: "TPL-1002", name: "PCB Soldering Line", status: "Active", stageCount: 5, activeRunCount: 0, updatedAt: "2026-07-18" }, - { templateId: 3, docNo: "TPL-1003", name: "Wooden Pallet Build", status: "Active", stageCount: 2, activeRunCount: 1, updatedAt: "2026-07-25" }, - { templateId: 4, docNo: "TPL-1004", name: "Plastic Injection Mold", status: "Inactive", stageCount: 4, activeRunCount: 0, updatedAt: "2026-07-10" }, - { templateId: 5, docNo: "TPL-1005", name: "Cable Harness Kit", status: "Active", stageCount: 3, activeRunCount: 0, updatedAt: "2026-07-22" }, -] type StatusFilter = TemplateStatus | "All" -function todayIso() { - return new Date().toISOString().slice(0, 10) -} +const PAGE_SIZE = 25 const nodeTypes = { lineHeader: LineHeaderNodeComponent, lineStage: LineStageNodeComponent } @@ -46,7 +36,7 @@ const STAGE_START_X = 300 const STAGE_GAP_X = 200 /** One row per template — its production line, header on the left, stages left to right. */ -function buildLinesGraph(templates: ProductionTemplate[]): { nodes: Node[]; edges: Edge[] } { +function buildLinesGraph(templates: ProductionTemplateSummary[]): { nodes: Node[]; edges: Edge[] } { const nodes: Node[] = [] const edges: Edge[] = [] @@ -58,7 +48,7 @@ function buildLinesGraph(templates: ProductionTemplate[]): { nodes: Node[]; edge position: { x: 0, y }, data: { templateId: t.templateId, - docNo: t.docNo, + code: t.code, name: t.name, status: t.status, activeRunCount: t.activeRunCount, @@ -66,8 +56,9 @@ function buildLinesGraph(templates: ProductionTemplate[]): { nodes: Node[]; edge draggable: false, }) - const stages = MOCK_TEMPLATE_INFO[t.templateId]?.stages ?? [] - stages.forEach((stageName, i) => { + // Names come straight from the list projection, so the overview needs one request + // regardless of how many templates it shows. + t.stageNames.forEach((stageName, i) => { const stageId = `s${t.templateId}-${i}` nodes.push({ id: stageId, @@ -90,32 +81,61 @@ function buildLinesGraph(templates: ProductionTemplate[]): { nodes: Node[]; edge export default function ProductionTemplatesPage() { const router = useRouter() const { resolvedTheme } = useTheme() - const [templates, setTemplates] = useState(INITIAL_TEMPLATES) + + // null = still loading (the codebase convention for "no data yet" vs "empty result"). + const [templates, setTemplates] = useState(null) + const [pagination, setPagination] = useState(null) + const [loadError, setLoadError] = useState(null) + const [searchInput, setSearchInput] = useState("") + const [query, setQuery] = useState("") const [status, setStatus] = useState("All") + const [page, setPage] = useState(1) const [open, setOpen] = useState(false) + const [code, setCode] = useState("") const [name, setName] = useState("") - const [error, setError] = useState("") - const [submitting, setSubmitting] = useState(false) + const [errors, setErrors] = useState<{ code?: string; name?: string }>({}) - // Same hydration-mismatch guard as the builder canvas (theme-toggle.tsx / templates/[id]/page.tsx): - // colorMode depends on resolvedTheme, which is unknown on the server and on first paint. + // Same hydration-mismatch guard as the builder canvas: colorMode depends on resolvedTheme, + // which is unknown on the server and on first paint. const [mounted, setMounted] = useState(false) useEffect(() => setMounted(true), []) - const filtered = useMemo(() => { - const q = searchInput.trim().toLowerCase() - return templates.filter((t) => { - if (status !== "All" && t.status !== status) return false - if (q && !t.name.toLowerCase().includes(q) && !t.docNo.toLowerCase().includes(q)) return false - return true - }) - }, [templates, searchInput, status]) + // 300ms debounce, matching app/dashboard/receiving/grn/page.tsx. Resets to page 1 with the + // query so a narrower search can't leave you stranded past the last page — done here rather + // than in a second effect watching [query, status], which would be a cascading render. + useEffect(() => { + const timer = setTimeout(() => { + setQuery(searchInput.trim()) + setPage(1) + }, 300) + return () => clearTimeout(timer) + }, [searchInput]) - const hasFilters = searchInput.trim().length > 0 || status !== "All" + const load = useCallback(() => { + setLoadError(null) + productionTemplatesApi + .list({ + page, + pageSize: PAGE_SIZE, + q: query || undefined, + status: status === "All" ? undefined : status, + }) + .then((res) => { + setTemplates(res.items) + setPagination(res.pagination) + }) + .catch((err) => { + setTemplates([]) + setLoadError(errorMessage(err)) + }) + }, [page, query, status]) - const { nodes, edges } = useMemo(() => buildLinesGraph(filtered), [filtered]) + useEffect(load, [load]) + + const hasFilters = query.length > 0 || status !== "All" + const { nodes, edges } = useMemo(() => buildLinesGraph(templates ?? []), [templates]) const onNodeClick: NodeMouseHandler = (_, node) => { const templateId = (node.data as LineHeaderData | LineStageData).templateId @@ -123,35 +143,30 @@ export default function ProductionTemplatesPage() { } function openCreateDialog() { + setCode("") setName("") - setError("") + setErrors({}) setOpen(true) } + /** + * Opens the builder on an unsaved draft rather than creating anything now. + * + * A template cannot exist without a valid graph: the server requires at least one stage and + * a terminal output naming a real finished item (FR-MFG-02/05). There is nothing sensible to + * POST from a name alone, so the draft lives in the builder and the first Save creates it. + */ function handleCreate() { - const trimmed = name.trim() - if (!trimmed) { - setError("Name is required.") - return - } - setSubmitting(true) - const nextId = templates.reduce((max, t) => Math.max(max, t.templateId), 0) + 1 - const created: ProductionTemplate = { - templateId: nextId, - docNo: `TPL-${1000 + nextId}`, - name: trimmed, - status: "Active", - stageCount: 0, - activeRunCount: 0, - updatedAt: todayIso(), - } - setTemplates((prev) => [...prev, created]) - toast.success("Template created", trimmed) + const nextErrors: { code?: string; name?: string } = {} + if (!code.trim()) nextErrors.code = "Code is required." + if (!name.trim()) nextErrors.name = "Name is required." + setErrors(nextErrors) + if (Object.keys(nextErrors).length > 0) return + setOpen(false) - setSubmitting(false) - // No backend exists yet, so the builder can't look this template up by id (its mock - // lookup only knows the 5 seeded ones) — pass the name through and start it blank. - router.push(`/dashboard/production/templates/${nextId}?name=${encodeURIComponent(trimmed)}&fresh=1`) + router.push( + `/dashboard/production/templates/new?code=${encodeURIComponent(code.trim())}&name=${encodeURIComponent(name.trim())}`, + ) } return ( @@ -166,28 +181,41 @@ export default function ProductionTemplatesPage() { New template - Give the template a name — you'll build its stage graph next. + + Name it, then build its stage graph. It's saved once the graph is valid. + - + + Code + setCode(e.target.value)} + placeholder="e.g. PT-CHAIR" + aria-invalid={!!errors.code} + /> + + + Name setName(e.target.value)} placeholder="e.g. Aluminium Frame Assembly" - aria-invalid={!!error} + aria-invalid={!!errors.name} onKeyDown={(e) => e.key === "Enter" && handleCreate()} /> - +
- -
@@ -200,7 +228,7 @@ export default function ProductionTemplatesPage() { setSearchInput(e.target.value)} - placeholder="Search templates…" + placeholder="Search by code or name…" className="h-14 w-full pl-11 text-base" aria-label="Search templates" /> @@ -217,7 +245,15 @@ export default function ProductionTemplatesPage() {
- {filtered.length === 0 ? ( + {loadError && ( +
+ {loadError} +
+ )} + + {templates === null ? ( + + ) : templates.length === 0 ? (

@@ -225,29 +261,52 @@ export default function ProductionTemplatesPage() {

) : ( -
- {mounted ? ( - - - - - ) : ( - + <> +
+ {mounted ? ( + + + + + ) : ( + + )} +
+ + {pagination && pagination.totalPages > 1 && ( +
+

+ Showing {(pagination.page - 1) * pagination.pageSize + 1}– + {Math.min(pagination.page * pagination.pageSize, pagination.totalItems)} of {pagination.totalItems} +

+
+ + +
+
)} -
+ )}
) diff --git a/Frontend/erp-system/components/Layouts/AppSidebar.tsx b/Frontend/erp-system/components/Layouts/AppSidebar.tsx index 2a19bdf..c80abe1 100644 --- a/Frontend/erp-system/components/Layouts/AppSidebar.tsx +++ b/Frontend/erp-system/components/Layouts/AppSidebar.tsx @@ -341,9 +341,9 @@ export function AppSidebar() { // flashing the full menu to a restricted role. Once resolved, a nav item // is visible if its own code is granted, or (for parents) if any child is. // - // "procurement" and "hrm" are exempted from that check (frontend-only): no role is - // currently seeded with NAV:procurement/NAV:hrm or their children server-side, which - // would hide the whole section for everyone. Remove each bypass once roles are granted + // "procurement", "hrm" and "production" are exempted from that check (frontend-only): no + // role is currently seeded with NAV:procurement/NAV:hrm/NAV:production or their children + // server-side, which would hide the whole section for everyone. Remove each bypass once roles are granted // the permission properly (Settings → Roles → Sidebar permissions) or a backend seed // grants it. This is also flagged in 02-SECURITY.md as the AR-09 sidebar-visibility // stopgap for HRM's salary/PII data — it hides HRM from the UI but doesn't enforce diff --git a/Frontend/erp-system/components/production/ProductionLineNodes.tsx b/Frontend/erp-system/components/production/ProductionLineNodes.tsx index 81c2168..0710fe0 100644 --- a/Frontend/erp-system/components/production/ProductionLineNodes.tsx +++ b/Frontend/erp-system/components/production/ProductionLineNodes.tsx @@ -5,7 +5,8 @@ import { cn } from "@/lib/utils" export interface LineHeaderData extends Record { templateId: number - docNo: string + /** The template's `code` (e.g. `PT-CHAIR`). Templates carry a code; only runs get a doc no. */ + code: string name: string status: "Active" | "Inactive" activeRunCount: number @@ -16,7 +17,7 @@ function LineHeaderNode({ data }: NodeProps & { data: LineHeaderData }) { return (
- {data.docNo} + {data.code} { docNo: string templateName: string - status: RunStatus + status: ProductionRunStatus } /** Left-most box on a run's production line — the run itself, not a stage. */ @@ -25,45 +25,96 @@ function RunHeaderNode({ data }: NodeProps & { data: RunHeaderData }) { export interface RunStageData extends Record { name: string + roleLabel: string | null state: StageStatus + isTerminal: boolean + isEntry: boolean + estimatedMinutes: number + /** Whole minutes once finished; null while still running (FR-MFG-19). */ + actualMinutes: number | null + /** Set once started — drives the "running" hint while actualMinutes is still null. */ + actualStartAt: string | null + /** + * Aggregate intake across this stage's Upstream inputs, or null when it has none (an entry + * stage draws entirely from stock). `delivered >= planned` is exactly the readiness rule the + * server applies, so the badge doubles as an explanation of why a stage is still Waiting. + */ + intake: { delivered: number; planned: number } | null + /** Σ availableToTransfer across outputs — WIP produced but not yet pushed downstream. */ + availableToTransfer: number + /** Marks the stage the operator is expected to act on next. */ isActive: boolean - /** Present only on the current (leftmost incomplete) stage of an InProgress run. */ - onAdvance?: () => void } -/** One stage on a run's production line, colored by its live status — the box the "give - * progress" action lives on: the active stage grows an Advance button to push it forward. */ -function RunStageNode({ data }: NodeProps & { data: RunStageData }) { +function fmt(n: number): string { + // Quantities are decimal(18,4) server-side; trailing zeros just add noise on a canvas card. + return Number(n.toFixed(4)).toLocaleString() +} + +/** + * One stage on a run's production line, positioned from the run's own `posX`/`posY` (copied + * from the template at creation) and colored by its live status. Clicking it opens the stage + * drawer — handled by the page via `onNodeClick`, not here. + */ +function RunStageNode({ data, selected }: NodeProps & { data: RunStageData }) { const color = STAGE_STATUS_COLOR[data.state] + const running = data.actualStartAt !== null && data.actualMinutes === null + const intakeShort = data.intake !== null && data.intake.delivered < data.intake.planned return (
-
- -

{data.name}

+
+ +

{data.name}

+ {data.isTerminal && ( + + + + )}
-

{STAGE_STATUS_LABEL[data.state]}

- {data.onAdvance && ( - + Intake {fmt(data.intake.delivered)} / {fmt(data.intake.planned)} +
+ )} + + {data.availableToTransfer > 0 && ( +
+ + {fmt(data.availableToTransfer)} to transfer +
)} diff --git a/Frontend/erp-system/components/production/stage-progress-strip.tsx b/Frontend/erp-system/components/production/stage-progress-strip.tsx index 9cfcf64..0e385c3 100644 --- a/Frontend/erp-system/components/production/stage-progress-strip.tsx +++ b/Frontend/erp-system/components/production/stage-progress-strip.tsx @@ -8,7 +8,7 @@ import { STAGE_STATUS_LABEL, STAGE_STATUS_ORDER, } from "@/lib/production-status-colors" -import { RunStatus, StageSummary } from "@/types/production" +import { ProductionRunStatus, StageSummary } from "@/types/production" /** * One segment per stage-status count (docs/21-FRONTEND-PHASE2.md §3). Completed runs render @@ -19,7 +19,7 @@ export function StageProgressStrip({ summary, className, }: { - status: RunStatus + status: ProductionRunStatus summary: StageSummary className?: string }) { diff --git a/Frontend/erp-system/lib/api/production-runs.ts b/Frontend/erp-system/lib/api/production-runs.ts new file mode 100644 index 0000000..539e326 --- /dev/null +++ b/Frontend/erp-system/lib/api/production-runs.ts @@ -0,0 +1,189 @@ +// One typed client method per production-run endpoint (docs/30-BACKEND-PHASE2.md §D.2–D.3, +// FR-MFG-08..19). +// +// Every stage action takes an `idempotencyKey`. The server accepts the header but does not +// store it (matching GRN confirm): replay safety comes from the status guards, so a +// double-fire returns a 409 rather than acting twice. Pass a per-action +// `useRef(crypto.randomUUID())` anyway — it is part of the contract and costs nothing. +// +// Treat a 409 carrying a stage-status code as "someone else moved first": refetch the run +// and re-render silently instead of showing an error (docs/21-FRONTEND-PHASE2.md §6). Use +// `isStaleStageError` for that check. +import { apiRequest, apiRequestWithETag, buildQuery } from "@/lib/api-client" +import { ApiResult, PagedResponse } from "@/types/common" +import { + ApproveStageRequest, + ApproveStageResult, + CancelRunRequest, + CancelRunResult, + CompleteStageRequest, + CreateRunRequest, + ProductionRunGraph, + ProductionRunStatus, + ProductionRunSummary, + RejectIntakeResult, + RejectRequest, + ReturnLeftoverRequest, + ReturnLeftoverResult, + RunStage, + StartStageResult, + TerminalRejectResult, + TransferRemainderRequest, + TransferResult, + UpdateStageQuantitiesRequest, +} from "@/types/production" + +export interface ListRunsParams { + page?: number + pageSize?: number + q?: string + status?: ProductionRunStatus + templateId?: number + warehouseId?: number + sort?: string +} + +export const productionRunsApi = { + list(params: ListRunsParams = {}): Promise> { + return apiRequest>(`/production-runs${buildQuery(params)}`) + }, + + get(runId: number): Promise> { + return apiRequestWithETag(`/production-runs/${runId}`) + }, + + create(request: CreateRunRequest): Promise> { + return apiRequestWithETag("/production-runs", { method: "POST", body: request }) + }, + + /** `409 STAGE_NOT_EDITABLE` once the stage has started (FR-MFG-08). */ + updateStageQuantities( + runId: number, + runStageId: number, + request: UpdateStageQuantitiesRequest, + ): Promise { + return apiRequest(`/production-runs/${runId}/stages/${runStageId}/quantities`, { + method: "PUT", + body: request, + }) + }, + + // --- stage actions --------------------------------------------------------- + + start(runId: number, runStageId: number, idempotencyKey?: string): Promise { + return apiRequest(`/production-runs/${runId}/stages/${runStageId}/start`, { + method: "POST", + idempotencyKey, + }) + }, + + complete( + runId: number, + runStageId: number, + request: CompleteStageRequest, + idempotencyKey?: string, + ): Promise { + return apiRequest(`/production-runs/${runId}/stages/${runStageId}/complete`, { + method: "POST", + body: request, + idempotencyKey, + }) + }, + + /** Non-terminal: transfers WIP to children. Terminal: posts the receipt and completes the run. */ + approve( + runId: number, + runStageId: number, + request: ApproveStageRequest = {}, + idempotencyKey?: string, + ): Promise { + return apiRequest(`/production-runs/${runId}/stages/${runStageId}/approve`, { + method: "POST", + body: request, + idempotencyKey, + }) + }, + + transfer( + runId: number, + runStageId: number, + request: TransferRemainderRequest, + idempotencyKey?: string, + ): Promise { + return apiRequest(`/production-runs/${runId}/stages/${runStageId}/transfer`, { + method: "POST", + body: request, + idempotencyKey, + }) + }, + + rejectIntake( + runId: number, + runStageId: number, + request: RejectRequest = {}, + idempotencyKey?: string, + ): Promise { + return apiRequest(`/production-runs/${runId}/stages/${runStageId}/reject-intake`, { + method: "POST", + body: request, + idempotencyKey, + }) + }, + + /** Terminal stage only — resets the entire run for a rework pass (FR-MFG-16). */ + rejectTerminal( + runId: number, + runStageId: number, + request: RejectRequest = {}, + idempotencyKey?: string, + ): Promise { + return apiRequest(`/production-runs/${runId}/stages/${runStageId}/reject`, { + method: "POST", + body: request, + idempotencyKey, + }) + }, + + // --- run-level actions ----------------------------------------------------- + + returnLeftover( + runId: number, + runInputId: number, + request: ReturnLeftoverRequest, + idempotencyKey?: string, + ): Promise { + return apiRequest(`/production-runs/${runId}/inputs/${runInputId}/return-leftover`, { + method: "POST", + body: request, + idempotencyKey, + }) + }, + + cancel(runId: number, request: CancelRunRequest, idempotencyKey?: string): Promise { + return apiRequest(`/production-runs/${runId}/cancel`, { + method: "POST", + body: request, + idempotencyKey, + }) + }, +} + +/** + * Stage-status conflicts, i.e. "the stage already moved on — probably another user". + * + * docs/21-FRONTEND-PHASE2.md §6 says to refetch the run silently and re-render for these + * rather than surfacing an error, which is also what makes the server's accept-and-ignore + * idempotency posture feel right: a double-click just refreshes. + */ +const STALE_STAGE_CODES = new Set([ + "STAGE_NOT_READY", + "STAGE_NOT_IN_PROGRESS", + "STAGE_NOT_DONE", + "STAGE_NOT_EDITABLE", + "STAGE_REJECT_INVALID", +]) + +export function isStaleStageError(error: unknown): boolean { + const code = (error as { code?: string } | null)?.code + return code !== undefined && STALE_STAGE_CODES.has(code) +} diff --git a/Frontend/erp-system/lib/api/production-templates.ts b/Frontend/erp-system/lib/api/production-templates.ts new file mode 100644 index 0000000..f992a36 --- /dev/null +++ b/Frontend/erp-system/lib/api/production-templates.ts @@ -0,0 +1,61 @@ +// One typed client method per production-template endpoint (docs/30-BACKEND-PHASE2.md §D.1, +// FR-MFG-01..07). ETag/If-Match on update, PATCH status for deactivate (templates are +// deactivated, never hard-deleted, FR-MFG-01). +// +// Note that `update` replaces the WHOLE graph, and that the server's stage/output keys are +// load-bearing: a key it recognises is diffed in place (so historical runs stay linked to the +// stage), while anything else — a `tmp-` from the canvas — is inserted. The builder holds +// those keys as React Flow node ids and echoes them back; see the [id]/types.ts header. +import { apiRequest, apiRequestWithETag, buildQuery } from "@/lib/api-client" +import { ApiResult, PagedResponse } from "@/types/common" +import { + ProductionTemplateGraph, + ProductionTemplateSummary, + SaveTemplateRequest, + TemplateStatus, +} from "@/types/production" + +export interface ListTemplatesParams { + page?: number + pageSize?: number + q?: string + status?: TemplateStatus + sort?: string +} + +export const productionTemplatesApi = { + list(params: ListTemplatesParams = {}): Promise> { + return apiRequest>(`/production-templates${buildQuery(params)}`) + }, + + get(templateId: number): Promise> { + return apiRequestWithETag(`/production-templates/${templateId}`) + }, + + create(request: SaveTemplateRequest): Promise> { + return apiRequestWithETag("/production-templates", { + method: "POST", + body: request, + }) + }, + + /** Full-graph replace. `409 TEMPLATE_IN_USE` while any run of this template is InProgress. */ + update( + templateId: number, + request: SaveTemplateRequest, + ifMatch: string, + ): Promise> { + return apiRequestWithETag(`/production-templates/${templateId}`, { + method: "PUT", + body: request, + ifMatch, + }) + }, + + updateStatus(templateId: number, status: TemplateStatus): Promise { + return apiRequest(`/production-templates/${templateId}/status`, { + method: "PATCH", + body: { status }, + }) + }, +} diff --git a/Frontend/erp-system/lib/error-map.ts b/Frontend/erp-system/lib/error-map.ts index ac8e1ec..8423f1b 100644 --- a/Frontend/erp-system/lib/error-map.ts +++ b/Frontend/erp-system/lib/error-map.ts @@ -16,6 +16,27 @@ interface ApiErrorLike { */ const GENERIC_CODES = new Set(["validation_error", "not_found", "conflict"]) +/** + * Domain codes whose server `detail` is *more* specific than any fixed copy, so the detail + * wins and the entry in the map below is only a fallback. + * + * The graph validator names the offending stages ("...contains a cycle involving: Cut frame, + * Assemble"), and the transfer/leftover guards quote the actual figures ("only 20 is + * available (produced 50 - scrapped 0 - transferred 30)"). Replacing that with generic prose + * would throw away exactly what the user needs to fix the problem — and, for the graph codes, + * what the canvas uses to focus the offending node (docs/21-FRONTEND-PHASE2.md §2). + */ +const DETAIL_PREFERRED_CODES = new Set([ + "GRAPH_CYCLE", + "GRAPH_TERMINAL_COUNT", + "GRAPH_DISCONNECTED", + "GRAPH_INPUT_SOURCE_INVALID", + "TERMINAL_OUTPUT_ITEM_REQUIRED", + "TRANSFER_EXCEEDS_AVAILABLE", + "LEFTOVER_EXCEEDS_CONSUMED", + "REQUIRED_FIELD_MISSING", +]) + const CODE_MESSAGES: Record = { OVER_RECEIPT_TOLERANCE: "This quantity exceeds the purchase order's open quantity beyond the allowed tolerance.", STOCK_NEGATIVE_BLOCKED: "Not enough available stock for this action.", @@ -41,6 +62,25 @@ const CODE_MESSAGES: Record = { SALARY_STRUCTURE_OVERLAP: "The new effective date must be after the current salary structure's effective date.", TAX_SLAB_GAP_INVALID: "This tax slab overlaps another slab for the same effective date.", PAYROLL_PERIOD_LOCKED: "This payroll run is locked.", + // Manufacturing / Production Lines (docs/30-BACKEND-PHASE2.md §D.4). Several of these are + // listed in DETAIL_PREFERRED_CODES above, so their copy here is only a fallback. + TEMPLATE_IN_USE: "This template has runs in progress and can't be edited until they finish.", + TEMPLATE_INACTIVE: "This template is inactive, so new runs can't be started from it.", + GRAPH_CYCLE: "The stages form a loop. Remove the connection that feeds back on itself.", + GRAPH_TERMINAL_COUNT: "Connect stages so the line converges to a single final stage.", + GRAPH_DISCONNECTED: "Every stage must sit on a path from a starting stage to the final stage.", + GRAPH_INPUT_SOURCE_INVALID: "An upstream input must draw from a stage directly feeding into it.", + TERMINAL_OUTPUT_ITEM_REQUIRED: "The final stage needs exactly one output, and it must name the finished item.", + STAGE_NOT_READY: "This stage isn't ready to start yet.", + STAGE_NOT_IN_PROGRESS: "This stage isn't in progress, so it can't be completed.", + STAGE_NOT_DONE: "This stage has to be completed before it can be approved.", + STAGE_NOT_EDITABLE: "Quantities can't be changed once the stage has started.", + STAGE_REJECT_INVALID: "This stage has no received work to reject.", + REQUIRED_FIELD_MISSING: "Fill in every required field before completing this stage.", + TRANSFER_EXCEEDS_AVAILABLE: "That's more than this stage has available to transfer.", + LEFTOVER_EXCEEDS_CONSUMED: "You can't return more than was consumed and not already returned.", + RUN_COST_CLOSED: "This run is complete — its costs are closed, so leftovers can't be returned.", + RUN_NOT_CANCELLABLE: "This run can no longer be cancelled.", validation_error: "Please check the highlighted fields.", not_found: "The requested record was not found.", conflict: "This action conflicts with the record's current state.", @@ -49,8 +89,16 @@ const CODE_MESSAGES: Record = { export function errorMessage(error: unknown): string { if (error && typeof error === "object") { const e = error as ApiErrorLike - // A specific domain code beats the server's prose; a generic one loses to it. - if (e.code && !GENERIC_CODES.has(e.code) && CODE_MESSAGES[e.code]) return CODE_MESSAGES[e.code] + // A specific domain code beats the server's prose; a generic one — or one whose detail + // carries the specifics — loses to it. + if ( + e.code && + !GENERIC_CODES.has(e.code) && + !(DETAIL_PREFERRED_CODES.has(e.code) && e.detail) && + CODE_MESSAGES[e.code] + ) { + return CODE_MESSAGES[e.code] + } if (e.detail) return e.detail if (e.code && CODE_MESSAGES[e.code]) return CODE_MESSAGES[e.code] } diff --git a/Frontend/erp-system/lib/production-mock-runs.ts b/Frontend/erp-system/lib/production-mock-runs.ts deleted file mode 100644 index a56701a..0000000 --- a/Frontend/erp-system/lib/production-mock-runs.ts +++ /dev/null @@ -1,105 +0,0 @@ -// Frontend-only mock run registry — no Dtos/Production backend exists yet -// (docs/21-FRONTEND-PHASE2.md). Shared by the Runs board and the run detail page so both -// read the same seed data (each page still keeps its own local edits — there's no backend -// to persist an advance/start-run action back to the other screen). -import { ProductionRun } from "@/types/production" -import { MOCK_TEMPLATE_INFO } from "@/lib/production-mock-templates" -import { STAGE_STATUS_ORDER, type StageStatus } from "@/lib/production-status-colors" - -export const INITIAL_RUNS: ProductionRun[] = [ - { - runId: 1, docNo: "PRD-2026-00001", templateName: "Steel Bracket Assembly", targetQty: 500, - finishedItemName: "Steel Bracket A", uom: "PCS", warehouseName: "Main Warehouse", status: "InProgress", - reworkCount: 0, createdAt: "2026-07-26", completedAt: null, - stageSummary: { waiting: 1, ready: 0, inProgress: 1, done: 1, approved: 0 }, - }, - { - runId: 2, docNo: "PRD-2026-00002", templateName: "PCB Soldering Line", targetQty: 200, - finishedItemName: "PCB Board X", uom: "PCS", warehouseName: "Colombo Warehouse", status: "InProgress", - reworkCount: 1, createdAt: "2026-07-25", completedAt: null, - stageSummary: { waiting: 0, ready: 1, inProgress: 2, done: 1, approved: 1 }, - }, - { - runId: 3, docNo: "PRD-2026-00003", templateName: "Wooden Pallet Build", targetQty: 1000, - finishedItemName: "Pallet Standard", uom: "PCS", warehouseName: "Main Warehouse", status: "Completed", - reworkCount: 0, createdAt: "2026-07-20", completedAt: "2026-07-24", - stageSummary: { waiting: 0, ready: 0, inProgress: 0, done: 0, approved: 2 }, - }, - { - runId: 4, docNo: "PRD-2026-00004", templateName: "Cable Harness Kit", targetQty: 300, - finishedItemName: "Harness Kit B", uom: "PCS", warehouseName: "Main Warehouse", status: "InProgress", - reworkCount: 0, createdAt: "2026-07-27", completedAt: null, - stageSummary: { waiting: 2, ready: 1, inProgress: 0, done: 0, approved: 0 }, - }, - { - runId: 5, docNo: "PRD-2026-00005", templateName: "Steel Bracket Assembly", targetQty: 150, - finishedItemName: "Steel Bracket A", uom: "PCS", warehouseName: "Colombo Warehouse", status: "Cancelled", - reworkCount: 0, createdAt: "2026-07-15", completedAt: null, - stageSummary: { waiting: 0, ready: 0, inProgress: 1, done: 0, approved: 0 }, - }, - { - runId: 6, docNo: "PRD-2026-00006", templateName: "PCB Soldering Line", targetQty: 400, - finishedItemName: "PCB Board X", uom: "PCS", warehouseName: "Main Warehouse", status: "InProgress", - reworkCount: 0, createdAt: "2026-07-23", completedAt: null, - stageSummary: { waiting: 1, ready: 2, inProgress: 1, done: 1, approved: 0 }, - }, -] - -// Active templates only (docs/21-FRONTEND-PHASE2.md §4 "Template picker (Active only)") — -// mirrors the 4 Active rows on the Template list page ("Plastic Injection Mold" is Inactive -// there, so it's excluded here too. `nominalBatchQty` backs the scaled-preview calculation; -// there's no real per-template formula graph shared across routes to scale properly (each -// builder page's stage data is local, unsaved state — see templates/[id]/page.tsx), so this -// is a simplified stand-in for the doc's full per-stage scaled preview. -export interface StartableTemplate { - templateId: number - name: string - finishedItemName: string - uom: string - nominalBatchQty: number - stageCount: number -} - -export const STARTABLE_TEMPLATES: StartableTemplate[] = [ - { templateId: 1, name: "Steel Bracket Assembly", finishedItemName: "Steel Bracket A", uom: "PCS", nominalBatchQty: 100, stageCount: 3 }, - { templateId: 2, name: "PCB Soldering Line", finishedItemName: "PCB Board X", uom: "PCS", nominalBatchQty: 50, stageCount: 5 }, - { templateId: 3, name: "Wooden Pallet Build", finishedItemName: "Pallet Standard", uom: "PCS", nominalBatchQty: 200, stageCount: 2 }, - { templateId: 5, name: "Cable Harness Kit", finishedItemName: "Harness Kit B", uom: "SET", nominalBatchQty: 75, stageCount: 3 }, -] - -export interface RunStagePlanItem { - name: string - state: StageStatus -} - -const SUMMARY_KEY_BY_STATUS: Record = { - Waiting: "waiting", - Ready: "ready", - InProgress: "inProgress", - Done: "done", - Approved: "approved", -} - -/** - * `stageSummary` only carries counts per status, not which named stage each count belongs - * to. Reconstruct a per-stage breakdown by looking up the template's real stage names (via - * MOCK_TEMPLATE_INFO) and allocating the counts across them most-complete-first — stages - * run left to right, so the furthest-along stages are assumed to be the earliest ones in - * the list. Pad with "Waiting" (and truncate) when the counts don't add up to the template's - * actual stage count — e.g. the Cancelled mock run stops partway through its stage list. - */ -export function buildStagePlan(templateName: string, summary: ProductionRun["stageSummary"]): RunStagePlanItem[] { - const info = Object.values(MOCK_TEMPLATE_INFO).find((t) => t.name === templateName) - const totalCount = Object.values(summary).reduce((sum, n) => sum + n, 0) - const stageNames = info?.stages ?? Array.from({ length: Math.max(totalCount, 1) }, (_, i) => `Stage ${i + 1}`) - - const statuses: StageStatus[] = [] - for (const s of [...STAGE_STATUS_ORDER].reverse()) { - const count = summary[SUMMARY_KEY_BY_STATUS[s]] - for (let i = 0; i < count; i++) statuses.push(s) - } - while (statuses.length < stageNames.length) statuses.push("Waiting") - statuses.length = stageNames.length - - return stageNames.map((name, i) => ({ name, state: statuses[i] })) -} diff --git a/Frontend/erp-system/lib/production-mock-templates.ts b/Frontend/erp-system/lib/production-mock-templates.ts deleted file mode 100644 index 6f83558..0000000 --- a/Frontend/erp-system/lib/production-mock-templates.ts +++ /dev/null @@ -1,16 +0,0 @@ -// Frontend-only mock template registry — no Dtos/Production backend exists yet -// (docs/21-FRONTEND-PHASE2.md). Shared by the Template list page (production-line preview -// per card) and the canvas builder page (initial graph + edit-lock), so the two never drift. -export interface MockTemplateInfo { - name: string - activeRunCount: number - stages: string[] -} - -export const MOCK_TEMPLATE_INFO: Record = { - "1": { name: "Steel Bracket Assembly", activeRunCount: 2, stages: ["Cutting", "Welding", "QA Inspection"] }, - "2": { name: "PCB Soldering Line", activeRunCount: 0, stages: ["Component Placement", "Soldering", "Inspection", "Cleaning", "Final Test"] }, - "3": { name: "Wooden Pallet Build", activeRunCount: 1, stages: ["Assembly", "Quality Check"] }, - "4": { name: "Plastic Injection Mold", activeRunCount: 0, stages: ["Mold Prep", "Injection", "Cooling", "Trimming"] }, - "5": { name: "Cable Harness Kit", activeRunCount: 0, stages: ["Wire Cutting", "Crimping", "Bundling"] }, -} diff --git a/Frontend/erp-system/package-lock.json b/Frontend/erp-system/package-lock.json index 4f3fa1e..46e02e2 100644 --- a/Frontend/erp-system/package-lock.json +++ b/Frontend/erp-system/package-lock.json @@ -12,6 +12,7 @@ "@hookform/resolvers": "^5.4.0", "@radix-ui/react-icons": "^1.3.2", "@tanstack/react-query": "^5.101.2", + "@xyflow/react": "^12.11.2", "chart.js": "^4.5.1", "class-variance-authority": "^0.7.1", "clsx": "^2.1.1", @@ -82,6 +83,7 @@ "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz", "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==", "license": "MIT", + "peer": true, "dependencies": { "@babel/code-frame": "^7.29.7", "@babel/generator": "^7.29.7", @@ -532,7 +534,8 @@ "version": "1.5.0", "resolved": "https://registry.npmjs.org/@date-fns/tz/-/tz-1.5.0.tgz", "integrity": "sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg==", - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/@dotenvx/dotenvx": { "version": "1.75.1", @@ -725,6 +728,7 @@ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz", "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==", "license": "MIT", + "peer": true, "engines": { "node": ">=12" }, @@ -768,32 +772,10 @@ "integrity": "sha512-VYJy0uhFm9zTJ1TxBaW/pA8bjbOM/OttaNMwZ1RHG4JKyRG7DhSdiqD1ipQoAyoD22olUtxbP78W9xY3Wd11bg==", "license": "BSD-3-Clause" }, - "node_modules/@emnapi/core": { - "version": "1.11.2", - "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.2.tgz", - "integrity": "sha512-TC8MkTuZUtcTSiFeuC0ksCh9QIJ5+F21MvZ4Wn4ORfYaFJ/0dsiudv5tVkejgwZlwQ39jL9WWDe2lz8x0WglOA==", - "dev": true, - "license": "MIT", - "optional": true, - "dependencies": { - "@emnapi/wasi-threads": "1.2.2", - "tslib": "^2.4.0" - } - }, - "node_modules/@emnapi/runtime": { - "version": "1.11.2", - "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.2.tgz", - "integrity": "sha512-kyOl3X0DuTiT1h2ft8r2fYO8JYtU9a9Xis/zBSiGArNaagCOWx90N1k2wxp18czFDH+OgcWGb5ZP/XMt3dcyPA==", - "license": "MIT", - "optional": true, - "dependencies": { - "tslib": "^2.4.0" - } - }, "node_modules/@emnapi/wasi-threads": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.2.tgz", - "integrity": "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA==", + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.3.tgz", + "integrity": "sha512-ELEBe8PsLvvJ6QMr0zLt8ffvOHW/dc1m3CEzNMg7aJUv3bMaoDtw2TXyDAwkYBuroxxuHEwhRTLJSe5sya547g==", "dev": true, "license": "MIT", "optional": true, @@ -2292,6 +2274,55 @@ "tslib": "^2.4.0" } }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "license": "MIT" + }, + "node_modules/@types/d3-drag": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz", + "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==", + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "license": "MIT", + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-selection": { + "version": "3.0.11", + "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz", + "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==", + "license": "MIT" + }, + "node_modules/@types/d3-transition": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz", + "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==", + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-zoom": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz", + "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==", + "license": "MIT", + "dependencies": { + "@types/d3-interpolate": "*", + "@types/d3-selection": "*" + } + }, "node_modules/@types/estree": { "version": "1.0.9", "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", @@ -2329,6 +2360,7 @@ "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==", "devOptional": true, "license": "MIT", + "peer": true, "dependencies": { "csstype": "^3.2.2" } @@ -2337,8 +2369,9 @@ "version": "19.2.3", "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz", "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==", - "dev": true, + "devOptional": true, "license": "MIT", + "peer": true, "peerDependencies": { "@types/react": "^19.2.0" } @@ -2394,6 +2427,7 @@ "integrity": "sha512-gwh4gvvlaVDKKxyfxMG+Gnu1u9X0OQBwyGLkbwB65dIzBKnxeRiJlNFqlI3zwVhNXJIs6qV7mlFCn/BIajlVig==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@typescript-eslint/scope-manager": "8.63.0", "@typescript-eslint/types": "8.63.0", @@ -2991,6 +3025,48 @@ "win32" ] }, + "node_modules/@xyflow/react": { + "version": "12.11.2", + "resolved": "https://registry.npmjs.org/@xyflow/react/-/react-12.11.2.tgz", + "integrity": "sha512-eLAlDWJfWnQEhJwGMjlWdAXO9eYllKpliUmPQlAmOLxz6mExXuzMVDUKLMquixgkrtmMFFtug3jGKmYYld12cA==", + "license": "MIT", + "dependencies": { + "@xyflow/system": "0.0.79", + "classcat": "^5.0.3", + "zustand": "^4.4.0" + }, + "peerDependencies": { + "@types/react": ">=17", + "@types/react-dom": ">=17", + "react": ">=17", + "react-dom": ">=17" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@xyflow/system": { + "version": "0.0.79", + "resolved": "https://registry.npmjs.org/@xyflow/system/-/system-0.0.79.tgz", + "integrity": "sha512-czLyOh91NF0hIzbNzwi8I6GlqG23BHh2435OddfI6uiaLH3xdrdygO93gqgH1Bv9mhy8XPFQJOBn1FTq4LvEWA==", + "license": "MIT", + "dependencies": { + "@types/d3-drag": "^3.0.7", + "@types/d3-interpolate": "^3.0.4", + "@types/d3-selection": "^3.0.10", + "@types/d3-transition": "^3.0.8", + "@types/d3-zoom": "^3.0.8", + "d3-drag": "^3.0.0", + "d3-interpolate": "^3.0.1", + "d3-selection": "^3.0.0", + "d3-zoom": "^3.0.0" + } + }, "node_modules/accepts": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", @@ -3010,6 +3086,7 @@ "integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==", "dev": true, "license": "MIT", + "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -3465,6 +3542,7 @@ } ], "license": "MIT", + "peer": true, "dependencies": { "baseline-browser-mapping": "^2.10.42", "caniuse-lite": "^1.0.30001800", @@ -3602,6 +3680,7 @@ "resolved": "https://registry.npmjs.org/chart.js/-/chart.js-4.5.1.tgz", "integrity": "sha512-GIjfiT9dbmHRiYi6Nl2yFCq7kkwdkp1W/lp2J99rX0yo9tgJGn3lKQATztIjb5tVtevcBtIdICNWqlq5+E8/Pw==", "license": "MIT", + "peer": true, "dependencies": { "@kurkle/color": "^0.3.0" }, @@ -3621,6 +3700,12 @@ "url": "https://polar.sh/cva" } }, + "node_modules/classcat": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/classcat/-/classcat-5.0.5.tgz", + "integrity": "sha512-JhZUT7JFcQy/EzW605k/ktHtncoo9vnyW/2GspNYwFlN1C/WmjuV/xtS04e9SOkL2sTdw0VAZ2UGCcQ9lR6p6w==", + "license": "MIT" + }, "node_modules/cli-cursor": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz", @@ -3908,6 +3993,112 @@ "devOptional": true, "license": "MIT" }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dispatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz", + "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-drag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz", + "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==", + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-selection": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-selection": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz", + "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==", + "license": "ISC", + "peer": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-transition": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz", + "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3", + "d3-dispatch": "1 - 3", + "d3-ease": "1 - 3", + "d3-interpolate": "1 - 3", + "d3-timer": "1 - 3" + }, + "engines": { + "node": ">=12" + }, + "peerDependencies": { + "d3-selection": "2 - 3" + } + }, + "node_modules/d3-zoom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz", + "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==", + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-drag": "2 - 3", + "d3-interpolate": "1 - 3", + "d3-selection": "2 - 3", + "d3-transition": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, "node_modules/damerau-levenshtein": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz", @@ -3974,6 +4165,7 @@ "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.4.0.tgz", "integrity": "sha512-+1UMbeh68lH1SegH83CGWwpb6OHHbpSgr3+s5Eww5M4CAgswBpoWS0AjTOfEJ33HiYKz1hdj/KTFprzXHmq/6w==", "license": "MIT", + "peer": true, "funding": { "type": "github", "url": "https://github.com/sponsors/kossnocorp" @@ -4502,6 +4694,7 @@ "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", @@ -4687,6 +4880,7 @@ "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@rtsao/scc": "^1.1.0", "array-includes": "^3.1.9", @@ -4976,6 +5170,7 @@ "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", "license": "MIT", + "peer": true, "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", @@ -5605,6 +5800,7 @@ "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.28.tgz", "integrity": "sha512-YwUvVpSF7m1yOblFPrU3Hbo8XhPheBoiyfGuII6z19LnOr6JpDnyyp7LFNrfV56wS8tpvtBFGRISHN02pDdLOA==", "license": "MIT", + "peer": true, "engines": { "node": ">=16.9.0" } @@ -7954,6 +8150,7 @@ "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz", "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==", "license": "MIT", + "peer": true, "engines": { "node": ">=0.10.0" } @@ -7999,6 +8196,7 @@ "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz", "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==", "license": "MIT", + "peer": true, "dependencies": { "scheduler": "^0.27.0" }, @@ -8011,6 +8209,7 @@ "resolved": "https://registry.npmjs.org/react-hook-form/-/react-hook-form-7.81.0.tgz", "integrity": "sha512-ocbmr2p5KBMoAfj4WCUvped33lVi1Kd5DuDUvQDnB6VEAacOjPI/jMbtDdbhco4y9ct4xUuCmMY0b/C9L0QHjw==", "license": "MIT", + "peer": true, "engines": { "node": ">=18.0.0" }, @@ -9142,6 +9341,7 @@ "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=12" }, @@ -9362,6 +9562,7 @@ "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "devOptional": true, "license": "Apache-2.0", + "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -9757,6 +9958,7 @@ "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz", "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==", "license": "MIT", + "peer": true, "funding": { "url": "https://github.com/sponsors/colinhacks" } @@ -9782,6 +9984,34 @@ "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } + }, + "node_modules/zustand": { + "version": "4.5.7", + "resolved": "https://registry.npmjs.org/zustand/-/zustand-4.5.7.tgz", + "integrity": "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw==", + "license": "MIT", + "dependencies": { + "use-sync-external-store": "^1.2.2" + }, + "engines": { + "node": ">=12.7.0" + }, + "peerDependencies": { + "@types/react": ">=16.8", + "immer": ">=9.0.6", + "react": ">=16.8" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "immer": { + "optional": true + }, + "react": { + "optional": true + } + } } } } diff --git a/Frontend/erp-system/types/production.ts b/Frontend/erp-system/types/production.ts index 8b71056..14c0b8e 100644 --- a/Frontend/erp-system/types/production.ts +++ b/Frontend/erp-system/types/production.ts @@ -1,23 +1,185 @@ -// Phase 2 (Manufacturing) frontend-only types — mirrors docs/21-FRONTEND-PHASE2.md. -// No backend contract exists yet (no Dtos/Production, no 30-BACKEND-PHASE2.md), so these -// are UI-shape placeholders for the mock data driving the Template list / Run board screens -// until the real API lands. +// Manufacturing / Production Lines DTOs (docs/30-BACKEND-PHASE2.md §D.1–D.3; FR-MFG-01..20). +// Mirrors the backend DTOs exactly — the API contract is the source of truth. +// +// Three things changed when the real backend landed, and they are worth knowing if you are +// reading old code or docs/21-FRONTEND-PHASE2.md: +// * a template is identified by `code`, not `docNo` (only runs carry a document number) +// * quantities reference `itemId`/`uomId` numeric FKs with `qtyPerBatch` — not free text +// * stages carry `posX`/`posY`, so canvas layout round-trips through the server +// +// The `key` vocabulary (§D.1): every stage and output has a client-facing string key +// alongside its database id. On a GET the key IS the stringified id; on a save you echo +// those keys back for rows you kept and mint `tmp-` keys for rows you just drew. +// Edges and Upstream inputs then reference stages/outputs *by key only*, which is what lets +// one payload shape serve both create (nothing has an id) and update (most things do). export type TemplateStatus = "Active" | "Inactive" +export type ProductionRunStatus = "InProgress" | "Completed" | "Cancelled" +export type RunStageStatus = "Waiting" | "Ready" | "InProgress" | "Done" | "Approved" +export type StageInputSource = "Stock" | "Upstream" +export type CustomFieldType = "Text" | "Number" | "Checkbox" | "Date" | "Select" -export interface ProductionTemplate { +export type RunStageEventType = + | "Start" + | "Complete" + | "Approve" + | "Transfer" + | "RejectIntake" + | "TerminalReject" + | "LeftoverReturn" + | "Cancel" + | "QuantityEdit" + +// --- templates --------------------------------------------------------------- + +/** One custom field definition, stored verbatim in the stage's `fieldDefs` jsonb (FR-MFG-07). */ +export interface FieldDef { + key: string + label: string + type: CustomFieldType + /** Only read when `type` is `Select`. */ + options: string[] | null + required: boolean +} + +export interface StageInput { + inputId: number + source: StageInputSource + /** Set when `source` is `Stock`; null when `Upstream`. */ + itemId: number | null + /** Set when `source` is `Upstream` — an output of a *direct* parent stage. */ + fromOutputId: number | null + fromOutputKey: string | null + uomId: number + qtyPerBatch: number +} + +export interface StageOutput { + outputId: number + key: string + /** Null on intermediate (WIP) outputs; required on the terminal stage's single output. */ + itemId: number | null + name: string + uomId: number + qtyPerBatch: number +} + +export interface TemplateStage { + stageId: number + key: string + name: string + roleLabel: string | null + estimatedMinutes: number + posX: number + posY: number + fieldDefs: FieldDef[] + inputs: StageInput[] + outputs: StageOutput[] +} + +export interface TemplateEdge { + edgeId: number + parentStageId: number + childStageId: number + parentKey: string + childKey: string +} + +/** Row on the template list. `activeRunCount > 0` means the builder is edit-locked (FR-MFG-06). */ +export interface ProductionTemplateSummary { templateId: number - docNo: string + code: string name: string status: TemplateStatus stageCount: number + /** Ordered by stage id — enough to label the overview canvas without fetching each graph. */ + stageNames: string[] activeRunCount: number - updatedAt: string + createdBy: number + createdAt: string } -export type RunStatus = "InProgress" | "Completed" | "Cancelled" +/** + * A canvas grouping box or divider line. Round-tripped verbatim through a jsonb column and + * completely invisible to the graph validator — annotations have no ports, no edges, and no + * bearing on whether a template is valid. + */ +export interface CanvasAnnotation { + kind: "box" | "line" + posX: number + posY: number + width: number + height: number + label: string | null + /** Degrees. Lines only. */ + rotation: number | null +} -/** One count per canonical stage status (docs/21-FRONTEND-PHASE2.md §3). */ +export interface ProductionTemplateGraph { + templateId: number + code: string + name: string + description: string | null + status: TemplateStatus + stages: TemplateStage[] + edges: TemplateEdge[] + annotations: CanvasAnnotation[] + /** `> 0` puts the builder in its read-only edit-locked state (FR-MFG-06). */ + activeRunCount: number + createdBy: number + createdAt: string +} + +// Save payloads. Narrow by design — status, ids, createdBy and timestamps are all +// server-controlled and rejected if sent (02-SECURITY §B.6). + +export interface SaveStageInputInput { + source: StageInputSource + itemId?: number | null + fromOutputKey?: string | null + uomId: number + qtyPerBatch: number +} + +export interface SaveStageOutputInput { + key: string + itemId?: number | null + name: string + uomId: number + qtyPerBatch: number +} + +export interface SaveStageInput { + key: string + name: string + roleLabel?: string | null + estimatedMinutes: number + posX: number + posY: number + fieldDefs: FieldDef[] + inputs: SaveStageInputInput[] + outputs: SaveStageOutputInput[] +} + +export interface SaveEdgeInput { + parentKey: string + childKey: string +} + +export interface SaveTemplateRequest { + code: string + name: string + description?: string | null + stages: SaveStageInput[] + /** Empty is legal — a single-stage template is both entry and terminal. */ + edges: SaveEdgeInput[] + /** Replaced wholesale on every save. Server caps the array at 200. */ + annotations: CanvasAnnotation[] +} + +// --- runs -------------------------------------------------------------------- + +/** Per-status stage counts driving the board's progress strip (FR-MFG-18). */ export interface StageSummary { waiting: number ready: number @@ -26,17 +188,304 @@ export interface StageSummary { approved: number } -export interface ProductionRun { +/** Derived server-side, never stored: `consumed − returned` across every run input. */ +export interface CostPool { + consumed: number + returned: number + net: number +} + +export interface RunStageInput { + runInputId: number + source: StageInputSource + itemId: number | null + fromRunOutputId: number | null + uomId: number + /** In the input's *declared* UOM. Editable until the stage starts. */ + plannedQty: number + /** + * The four figures below are in the item's *base* UOM — the only unit the FIFO engine and + * the ledger speak. A stage input declared in "box of 12" therefore shows plannedQty 3 and + * consumedQty 36. Do not compare them to plannedQty without converting. + */ + consumedQty: number + consumedValue: number + returnedQty: number + returnedValue: number + /** Upstream inputs only: accumulated by parent transfers. */ + deliveredQty: number +} + +export interface RunStageOutput { + runOutputId: number + itemId: number | null + name: string + uomId: number + plannedQty: number + producedQty: number + scrappedQty: number + scrapReasonCodeId: number | null + transferredQty: number + /** Derived: produced − scrapped − transferred (FR-MFG-12). */ + availableToTransfer: number +} + +export interface RunStage { + runStageId: number + templateStageId: number | null + name: string + roleLabel: string | null + estimatedMinutes: number + posX: number + posY: number + status: RunStageStatus + /** Derived from the run edge set — no outbound edge. */ + isTerminal: boolean + /** Derived — no inbound edge; Ready from run creation. */ + isEntry: boolean + actualStartAt: string | null + actualEndAt: string | null + /** Whole minutes once finished; null while still running (FR-MFG-19). */ + actualMinutes: number | null + fieldDefs: FieldDef[] + /** Captured at complete, keyed by `fieldDefs[].key`. */ + fieldValues: Record | null + inputs: RunStageInput[] + outputs: RunStageOutput[] +} + +export interface RunEdge { + runEdgeId: number + parentRunStageId: number + childRunStageId: number +} + +export interface RunEvent { + eventId: number + /** Null for run-level events (cancel). */ + runStageId: number | null + eventType: RunStageEventType + note: string | null + payload: Record | null + userId: number + createdAt: string +} + +/** Row on the run board (docs/30 §D.2). */ +export interface ProductionRunSummary { runId: number docNo: string + templateId: number templateName: string targetQty: number - finishedItemName: string - uom: string - warehouseName: string - status: RunStatus + status: ProductionRunStatus reworkCount: number + stageSummary: StageSummary + warehouseId: number + finishedItemId: number | null + finishedItemName: string | null + createdBy: number createdAt: string completedAt: string | null - stageSummary: StageSummary +} + +export interface ProductionRunGraph { + runId: number + docNo: string + templateId: number + templateName: string + warehouseId: number + outputBinId: number | null + targetQty: number + scaleFactor: number + status: ProductionRunStatus + reworkCount: number + cancelReasonCodeId: number | null + costPool: CostPool + stages: RunStage[] + edges: RunEdge[] + events: RunEvent[] + createdBy: number + createdAt: string + completedAt: string | null +} + +export interface CreateRunRequest { + templateId: number + targetQty: number + warehouseId: number + outputBinId?: number | null +} + +/** `id` is the runInputId or runOutputId being adjusted. */ +export interface StageQuantityLine { + id: number + plannedQty: number +} + +export interface UpdateStageQuantitiesRequest { + inputs: StageQuantityLine[] + outputs: StageQuantityLine[] +} + +// --- stage action results ---------------------------------------------------- + +export interface ConsumedLayer { + layerId: number + qty: number + unitCost: number +} + +export interface ConsumedInput { + runInputId: number + itemId: number + /** Base UOM. */ + qty: number + value: number + consumedLayers: ConsumedLayer[] +} + +export interface StartStageResult { + runStageId: number + status: RunStageStatus + actualStartAt: string | null + consumed: ConsumedInput[] + ledgerRefs: number[] + stage: RunStage +} + +export interface CompleteOutputLine { + runOutputId: number + producedQty: number + scrappedQty: number + /** Required once `scrappedQty > 0`; must be a Production-context reason. */ + scrapReasonCodeId?: number | null +} + +export interface CompleteStageRequest { + outputs: CompleteOutputLine[] + fieldValues?: Record | null +} + +export interface Transfer { + runOutputId: number + runInputId: number + childRunStageId: number + qty: number + childDeliveredQty: number + childStatus: RunStageStatus +} + +export interface Receipt { + layerId: number + itemId: number + warehouseId: number + binId: number | null + qtyReceived: number + unitCost: number + value: number +} + +export interface ApproveStageResult { + runStageId: number + status: RunStageStatus + runStatus: ProductionRunStatus + transfers: Transfer[] + /** Terminal approve only. */ + receipt: Receipt | null + costPool: CostPool | null + ledgerRefs: number[] + stage: RunStage +} + +export interface TransferLine { + runOutputId: number + qty: number + /** Optional explicit target when one output feeds several child inputs. */ + runInputId?: number | null +} + +export interface ApproveStageRequest { + /** Omit or leave empty to transfer the full available quantity of every output. */ + transfers?: TransferLine[] +} + +export interface TransferRemainderRequest { + runOutputId: number + qty: number + runInputId?: number | null +} + +export interface TransferResult { + runStageId: number + transfers: Transfer[] + stage: RunStage +} + +export interface ReturnLeftoverRequest { + /** In the item's *base* UOM, matching `consumedQty`. */ + qty: number + reasonCodeId: number +} + +export interface ReturnLeftoverResult { + runInputId: number + returnedQty: number + returnedValue: number + createdLayer: { layerId: number; unitCost: number } + ledgerRefs: number[] + costPool: CostPool +} + +export interface RejectRequest { + note?: string | null +} + +export interface PulledBack { + runInputId: number + parentRunStageId: number + parentRunOutputId: number + qty: number + priorParentStatus: RunStageStatus + parentStatus: RunStageStatus +} + +export interface RejectIntakeResult { + runStageId: number + status: RunStageStatus + pulledBack: PulledBack[] + run: ProductionRunGraph +} + +export interface TerminalRejectResult { + runStageId: number + reworkCount: number + run: ProductionRunGraph +} + +export interface CancelRunRequest { + reasonCodeId: number + note?: string | null +} + +export interface CancelReturn { + itemId: number + qty: number + unitCost: number + layerId: number +} + +/** Scrap never entered stock, so it is written off on the event rather than returned. */ +export interface ScrapWriteOff { + runOutputId: number + name: string + qty: number +} + +export interface CancelRunResult { + runId: number + status: ProductionRunStatus + returns: CancelReturn[] + scrappedWrittenOff: ScrapWriteOff[] + ledgerRefs: number[] } diff --git a/Frontend/erp-system/types/stock.ts b/Frontend/erp-system/types/stock.ts index 8ae6d43..661d57d 100644 --- a/Frontend/erp-system/types/stock.ts +++ b/Frontend/erp-system/types/stock.ts @@ -278,7 +278,8 @@ export type ReorderRequisitionResponse = Requisition // --- §6 Reference data ------------------------------------------------------------------ /** Server enum is Adjustment | Return | Count (docs/11 §6). */ -export type ReasonCodeContext = "Adjustment" | "Return" | "Count" +/** `Production` was added with Phase 2 (docs/30 §A.2) — scrap, leftover, cancel and rework loss. */ +export type ReasonCodeContext = "Adjustment" | "Return" | "Count" | "Production" export interface ReasonCode { reasonCodeId: number diff --git a/docs/00-CORE.md b/docs/00-CORE.md index e50cc97..1d2d258 100644 --- a/docs/00-CORE.md +++ b/docs/00-CORE.md @@ -342,6 +342,8 @@ All frontend work is governed by `20-FRONTEND.md`. | HRM API endpoints, request/response shapes, error catalog (Phase 2) | **`13-BACKEND-HRM-API.md`** | | Frontend user-flows, screen flow, architecture rules, validation posture (Phase 1) | **`20-FRONTEND.md`** | | HRM frontend user-flows (Phase 2) | **`21-FRONTEND-HRM.md`** | +| Manufacturing requirements, business rules, entities, stock/costing integration, API (Phase 2) | **`30-BACKEND-PHASE2.md`** | +| Manufacturing frontend user-flows — template canvas, run board, run execution (Phase 2) | **`21-FRONTEND-PHASE2.md`** | | Security risks per feature, accepted-risk register, pre-ship checklist | **`02-SECURITY.md`** | | Understanding the doc system, reading order, tracking conventions | **`01-DOC-GUIDE.md`** | | Recording backend changes made | **`Backend/PROGRESS.md`** | diff --git a/docs/01-DOC-GUIDE.md b/docs/01-DOC-GUIDE.md index c61164c..f353525 100644 --- a/docs/01-DOC-GUIDE.md +++ b/docs/01-DOC-GUIDE.md @@ -40,11 +40,15 @@ | `13-BACKEND-HRM-API.md` | High | HRM **API reference**: every endpoint, error catalog additions, enums. | Any HRM API contract / controller work. | Claude + humans | | `20-FRONTEND.md` | High | Frontend **user-flows**, architecture rules to follow, **validation posture**. | Any frontend work (Phase 1). | Claude + humans | | `21-FRONTEND-HRM.md` | High | HRM frontend **user-flows**, screens, validation specifics. | Any HRM frontend work. | Claude + humans | +| `30-BACKEND-PHASE2.md` | High | Manufacturing (Production Lines) backend: SRS, ER model, status machines, stock/costing integration, **and** the full API contract — model and API in one doc, unlike Phase 1. Schema is **authoritative** here. | Any manufacturing model / rule / API work. | Claude + humans | +| `21-FRONTEND-PHASE2.md` | High | Manufacturing frontend **user-flows**: template canvas builder, run board, run execution screens. | Any manufacturing frontend work. | Claude + humans | | `Backend/PROGRESS.md` | Low | Backend **change checklist**, git-shared. | After making backend changes. | **Claude** | | `Frontend/PROGRESS.md` | Low | Frontend **change checklist**, git-shared. | After making frontend changes. | **Claude** | Numbering convention: `0x` = high-level hub/guide/cross-cutting, `1x` = backend, `2x` = frontend. Numbers sort in read order in any file browser. +> **Known deviation:** `30-BACKEND-PHASE2.md` is a backend doc numbered `3x` rather than continuing the `1x` decade, and it merges the model and the API contract into one file instead of the `10`/`11` split. Left as-is — it is already the established reference for the manufacturing phase and renumbering it would invalidate every existing cross-reference. New backend phases should return to the `1x` convention. + --- ## 3. Reading order (first time) diff --git a/docs/21-FRONTEND-PHASE2.md b/docs/21-FRONTEND-PHASE2.md index c4c98c9..fc27877 100644 --- a/docs/21-FRONTEND-PHASE2.md +++ b/docs/21-FRONTEND-PHASE2.md @@ -6,7 +6,7 @@ ## 1. Screens -| Screen | Route (suggested) | Actual route (frontend-only build) | Purpose | +| Screen | Route (suggested) | Actual route (as built) | Purpose | |---|---|---|---| | Template list | `/production/templates` | `/dashboard/production/templates` — a single shared React Flow canvas, one row per template (header + stages left→right), not a list/grid | Browse templates, status, active-run count; open builder. | | Template builder (canvas) | `/production/templates/{id}` | `/dashboard/production/templates/{id}` | Drag-and-drop stage graph design. | @@ -14,7 +14,18 @@ | Start run dialog | modal from board/list | modal from run board | Pick template, target qty, warehouse; preview scaled quantities. | | Run detail | `/production/runs/{id}` | `/dashboard/production/runs/{id}` | Read-only graph with live statuses + stage action drawer. | -> **Build status:** §§1–4 are implemented as a **frontend-only mock** (per-page `useState`, no persistence across pages/reloads) — no `Dtos/Production` or `30-BACKEND-PHASE2.md` exist yet, so nothing here talks to a real API. §5 (Run detail) is implemented in a **simplified form**: one generic per-stage advance action instead of the full status-specific stage drawer. §6 (validation/error posture) does not apply yet — there's no server to surface `ProblemDetails`/error codes from. See §8 for the itemized gap list. +> **Build status (updated 2026-07-30).** The **backend is complete** — `Dtos/Production`, both controllers and the full `30-BACKEND-PHASE2.md` contract all exist, last verified at 312/312 smoke assertions (`Backend/smoke/run_all.py`). **Every frontend screen is now wired to it and both mock modules are deleted:** +> +> | Piece | State | +> |---|---| +> | Contract layer — `types/production.ts`, `lib/api/production-templates.ts`, `lib/api/production-runs.ts`, error-code map | **Done**, mirrors §D.1–D.4 | +> | §1 Template overview | **Real API** — live list, debounced search, status filter, paging | +> | §2 Template builder | **Real API** — loads/saves the graph with server keys, `If-Match`, persisted positions, real item/UOM pickers | +> | §3 Run board · §4 Start dialog | **Real API** — filters + paging; the dialog posts and navigates to the run | +> | §5 Run detail + stage drawer | **Real API** — canvas from the run's own positions/edges, and the full per-status action set | +> | §6 Validation posture | **Done** — `412` banner, server-driven `409 TEMPLATE_IN_USE` lock, per-action `Idempotency-Key`, silent stage-status `409` refetch | +> +> **Caveat, stated plainly: none of it has been driven in a browser.** The tree type-checks and Turbopack compiles it, but no screen has been clicked and no end-to-end run walked through the UI — blocked on AuthHex being unable to issue a token. §8 records the remaining live deviations; `Frontend/PROGRESS.md` §§11–13 is the authoritative state. --- @@ -70,7 +81,13 @@ These colors are the single source for status coloring everywhere (board, run gr ## 5. Run detail -> **As built (mock):** a single-row React Flow line (header box + one box per real stage name, left→right) instead of the full copied-template graph, with a header progress bar/percentage and one **Give Progress** action (canvas button on the active stage, and a mirrored button in the header) that steps that stage through the canonical status sequence `Waiting → Ready → InProgress → Done → Approved`. No drawer, no per-status action set, no quantities/scrap/custom-field forms, no delivered/available badges, no polling (single local page, no backend to refetch from). All state is local `useState` — reloading the page resets to the seeded mock run. See §8. +> **AS BUILT — this section is implemented as specified, with three deviations worth naming:** +> +> - **Refetch, not poll.** The page reloads the whole run after every action rather than polling on a timer; the drawer's body is switched on the *server's* stage status, so nothing is ever rendered from a local guess. A stage-status `409` also triggers a silent refetch (§6), which covers the "someone else acted first" case a poll would have caught. +> - **No inbound-edge badges; intake lives on the node.** React Flow edge labels are cramped and a stage can have several upstream inputs from the same parent, so the aggregate `delivered/planned` badge sits on the *stage card* — colour-coded, so it doubles as an explanation of why a stage is still `Waiting`. The available-to-transfer badge is on the card too. +> - **Delivery progress is a labelled figure, not a bar.** Per-upstream-input `delivered / planned` reads better as numbers in the drawer's input list than as a row of bars, and it keeps the base-UOM vs declared-UOM distinction visible (see the consumed/returned note in `30-BACKEND-PHASE2 §D.3`). +> +> Files: `runs/[id]/page.tsx` (canvas + header), `StageDrawer.tsx` (shell + every per-status body + event timeline), `CustomFieldForm.tsx` (runtime field renderer), `RunActions.tsx` (run-level Return leftover / Cancel). **Layout:** the template graph re-rendered read-only (same React Flow canvas, positions from the run's copied stages), each node colored by live status, with `deliveredQty/plannedQty` badges on inbound edges and an available-to-transfer badge on approved stages holding a remainder. Poll or refetch after every action. @@ -99,24 +116,27 @@ These colors are the single source for status coloring everywhere (board, run gr ## 7. Foundation additions (PROGRESS seed) - [x] React Flow dependency + canvas components — but **not** a single shared editable/read-only variant: the template-overview canvas (`templates/page.tsx`), the builder canvas (`templates/[id]/page.tsx`), and the run-detail canvas (`runs/[id]/page.tsx`) are three separate node-type sets (`ProductionLineNodes.tsx`, `StageNode.tsx`/`AnnotationNodes.tsx`, `RunStageNode.tsx`). -- [ ] Types mirroring `Dtos/Production` (template graph, run graph, stage actions) — not started; `types/production.ts` is a standalone frontend-only placeholder shape, nothing to mirror against yet. +- [x] Types mirroring `Dtos/Production` (template graph, run graph, stage actions) — `types/production.ts`, rewritten against `30-BACKEND-PHASE2 §D`. The placeholder shapes are gone. - [x] Status-color tokens (§3 table) exported from one module — `lib/production-status-colors.ts` (`STAGE_STATUS_COLOR`/`_LABEL`/`_ORDER`, `RUN_CANCELLED_COLOR`, `RUN_COMPLETED_COLOR`). -- [~] Custom-field renderer (defs jsonb → form) + builder (form → defs jsonb) — builder half only (`StageEditorPanel.tsx`, defs jsonb ← form). The runtime renderer (form → filled values, used during the spec'd Complete action) doesn't exist since there's no stage drawer/Complete step (§5). -- [~] Screens: template list · builder · run board · start dialog · run detail + drawer — list/builder/board/dialog implemented (as mock); run detail implemented **without** the drawer or per-status action set (§5, §8). -- [ ] Error-code → message map for §D.4 additions — not started, no backend/`ProblemDetails` to map yet. +- [x] Custom-field renderer (defs jsonb → form) + builder (form → defs jsonb) — both halves: the designer in `StageEditorPanel.tsx`, and the runtime renderer in `runs/[id]/CustomFieldForm.tsx`, used by the drawer's Complete action. +- [x] Screens: template list · builder · run board · start dialog · run detail + drawer — all implemented against the real API. +- [x] Error-code → message map for §D.4 additions — all 17 codes in `lib/error-map.ts`. --- -## 8. Gaps vs. this spec (frontend-only mock — no `Dtos/Production` / `30-BACKEND-PHASE2.md` yet) +## 8. Gaps vs. this spec -Everything below is intentional scope for the current build, not a bug — recorded so whoever wires up the real backend knows exactly what's still owed against this doc: +> **Closed.** Everything below was intentional scope while no backend existed; the backend is built and verified and every screen is now wired to it. Struck-through items are done; what remains is a short list of live deviations and one honest caveat. -- **No persistence.** All state is per-page `useState` seeded from hardcoded mock arrays (`lib/production-mock-templates.ts`, `lib/production-mock-runs.ts`). Templates, runs, and stage-status edits don't survive a reload and don't sync across the three canvases/pages. -- **Run detail is a simplified single action, not the stage drawer (§5).** One generic "Give Progress" step (Waiting→Ready→InProgress→Done→Approved) replaces Start/Complete (qty+scrap+custom fields)/Approve/Reject/Transfer remainder/Reject intake. No event history timeline, no actual-vs-estimated time tracking, no delivered/available badges. -- **No run-level actions.** Return leftover and Cancel run (§5) aren't implemented. -- **Stage identity on the run board/detail is reconstructed, not authoritative.** `ProductionRun.stageSummary` only carries counts per status; `buildStagePlan()` (`lib/production-mock-runs.ts`) maps those counts onto the template's real stage names most-complete-first as a display approximation — a real backend would return named per-stage records directly. -- **No validation/error posture (§6).** No `ProblemDetails`, no domain error-code mapping, no `412`/`409` handling, no `Idempotency-Key` — there's no server to produce any of it yet. -- **Save uses no `If-Match`/concurrency token** on the builder (§2) — a local `locked` boolean (from mock `activeRunCount`) stands in for the server's `409 TEMPLATE_IN_USE` edit lock. -- **Template overview deviates from "list" (§1).** Implemented as one shared canvas (all templates as production lines, one row each) instead of a browsable list/grid, per explicit product direction during the build. +- ~~**No persistence.**~~ Both mock modules (`lib/production-mock-templates.ts`, `lib/production-mock-runs.ts`) are **deleted**. Every screen reads and writes the real API. +- ~~**Run detail is a simplified single action, not the stage drawer (§5).**~~ The drawer (`runs/[id]/StageDrawer.tsx`) implements the full per-status action set — Start, Complete (qty + scrap + reason + custom fields), Approve with optional partial transfer, the terminal receipt confirmation, Reject for rework, Transfer remainder, Reject intake — plus the per-stage event timeline and estimated-vs-actual time with a live elapsed counter while a stage is running. +- ~~**No run-level actions.**~~ `runs/[id]/RunActions.tsx` implements Return leftover and Cancel run, both hidden once the run leaves `InProgress`. +- ~~**Stage identity on the run board/detail is reconstructed, not authoritative.**~~ `buildStagePlan()` is deleted. Run detail renders named per-stage records straight from `GET /production-runs/{id}`. **The board deliberately does not name stages at all** — its list projection carries `stageSummary` counts only, so it shows counts per status rather than guessing which stage holds which count. +- ~~**Validation/error posture (§6).**~~ Fully closed: the `412` conflict banner, the server-driven `409 TEMPLATE_IN_USE` lock banner (with a distinct message for the mid-edit TOCTOU case), per-action `Idempotency-Key`, and silent refetch on stage-status `409`s via `isStaleStageError()`. +- ~~**Save uses no `If-Match`/concurrency token** on the builder (§2).~~ It holds the ETag from the GET and sends `If-Match` on every `PUT`; the lock now comes from the server's `activeRunCount`, not a local boolean. +- **Template overview deviates from "list" (§1).** Still one shared canvas (all templates as production lines, one row each) instead of a browsable list/grid, per explicit product direction during the build. It now has a real debounced search, status filter and pagination around it. +- **`422 GRAPH_*` node focus is a substring match, not a structured reference.** The server's `detail` names the offending stages rather than returning their keys, so the builder highlights any stage whose name appears in the message. Advisory by design: the full message is always shown too, so an ambiguous name costs a highlight, never the explanation. +- **Canvas annotations are a frontend feature that grew a backend column.** The builder's grouping boxes and divider lines had nowhere to persist, which meant every save silently discarded them. They now round-trip through `PRODUCTION_TEMPLATE.annotations`; see the AS BUILT note in `30-BACKEND-PHASE2` Part C, including the client obligation to echo them back on a `PUT`. +- **Not browser-verified.** Every screen type-checks and Turbopack compiles the tree, and every endpoint behind them is smoke-verified server-side — but **no production screen has been driven in a browser and no end-to-end run has been walked through the UI.** Blocked on AuthHex being unable to issue a token (its configured MySQL host is unreachable). Tracked in `Frontend/PROGRESS.md §13`. *End of 21-FRONTEND-PHASE2.md. Contract: `30-BACKEND-PHASE2.md`. Record work: `Frontend/PROGRESS.md`.* diff --git a/docs/30-BACKEND-PHASE2.md b/docs/30-BACKEND-PHASE2.md new file mode 100644 index 0000000..eeb1fb5 --- /dev/null +++ b/docs/30-BACKEND-PHASE2.md @@ -0,0 +1,364 @@ +# 30 · BACKEND-PHASE2 — Manufacturing: Production Lines (Model, Rules & API) + +> **Purpose:** Single backend source of truth for Phase 2 (Manufacturing / Production Lines): requirements, entity model, business rules, status machines, stock/costing integration, and the full API contract. Frontend consumption rules live in `21-FRONTEND-PHASE2.md`. Register this doc in `00-CORE.md §7` routing and `01-DOC-GUIDE.md §2`. +> +> **Phase note:** Manufacturing is implemented as **Phase 2**; Sales & CRM moves to a later phase. This phase builds on the Phase-1 Manufacturing seam (`10-BACKEND-PHASE1 §B.7`): the generic FIFO goods-issue/consumption engine (`FifoCostingService.ConsumeAsync`) is the consumption path, extending FR-STK-03. + +--- + +## Part A — Architecture placement + +- **Services:** `Services/Production/ProductionTemplateService` (template CRUD + graph validation) and `Services/Production/ProductionRunService` (run lifecycle, stage transitions, transfers, receipt). Both follow the Phase-1 layering: controllers → services → repositories/UoW; entities never leave the service layer (DTOs in `Dtos/Production`). +- **FIFO integration:** all stock consumption goes through the existing `FifoCostingService.ConsumeAsync` (oldest-first, `SELECT … FOR UPDATE` row-locked, on-hold + expired excluded) **inside** the UoW transaction — never a parallel consumption path. Production receipt and leftover returns create layers through `FifoCostingService` inbound posting, same as GRN/transfer-receive. +- **Transactions:** every stock-affecting action (stage start, leftover return, terminal receipt, run cancel) runs in one `ExecuteInTransactionAsync` scope (NFR-02/NFR-05). Document numbers (`PRD-…`) issue via the existing `NumberSequenceService` inside the same transaction. +- **Concurrency:** templates and runs carry the `xmin` ETag token; mutating endpoints require `If-Match` (412 `CONCURRENCY_CONFLICT`). Stage-transition endpoints additionally guard on current status (409 on wrong state) so two users can't double-fire an action. +- **Ledger:** every stock movement posts to the append-only `STOCK_LEDGER` with new `source_doc_type` values (`ProductionIssue`, `ProductionReceipt`, `ProductionReturn`, `ProductionCancelReturn`). GL-ready journal entries emitted as data, same posture as FR-STK-13. + +### A.1 Phase-1 schema deviation (explicit) +NFR-08 says Phase 2+ integrates **without altering Phase-1 schema**. One deviation was anticipated here: + +- `STOCK_LAYER.grn_line_id` becomes **nullable** — a production receipt creates a layer with no GRN line. Layer origin remains fully traceable through the ledger (`source_doc_type='PRDR'`, `source_doc_id=run_id`). + +> **AS BUILT — this is a no-op; no migration was written.** `StockLayer.GrnLineId` was **already** `int?` in the entity, in `StockLayerConfiguration` (no `IsRequired`), in the model snapshot, and in the live database — `TransferService.ReceiveAsync` and `StockMutator` already pass `null`. Verified against `information_schema` before M1. Phase-1 schema was therefore **not altered at all** by manufacturing, and NFR-08 holds without exception. + +(Sales' `hold_status` addition is *not* pulled in here; it stays with the Sales phase.) + +### A.2 Enum extensions (additive) +- `ReasonContext` += `Production` (covers scrap, leftover return, cancel return). Seed reason codes: `PRD-SCRAP`, `PRD-LEFTOVER`, `PRD-CANCEL`, `PRD-REWORK-LOSS`. +- Ledger `source_doc_type` += four manufacturing movement types. + +> **AS BUILT — short codes, not the long names.** Both `stock_ledger.SourceDocType` and `journal_entry_stubs.SourceDocType` are `varchar(10)`, and every existing value is a short prefix (`GRN`, `TRF`, `ADJ`, `PRET`). The originally proposed `ProductionIssue` (15) / `ProductionReceipt` (17) / `ProductionReturn` (16) / `ProductionCancelReturn` (22) do not fit, and widening the columns would have been a *second* Phase-1 schema change beyond the single deviation §A.1 declares. The values are therefore: +> +> | Movement | Code | Direction | +> |---|---|---| +> | Stock consumed at stage start (FR-MFG-10) | `PRDI` | Out | +> | Finished-goods receipt (FR-MFG-13) | `PRDR` | In | +> | Leftover return (FR-MFG-14) | `PRDL` | In | +> | Cancel return (FR-MFG-17) | `PRDC` | In | +> +> Defined as consts in `Domain/LedgerSourceTypes.cs`. `source_doc_id` is always the `run_id`, so `source_doc_type LIKE 'PRD%'` traces every stock movement one run caused. The run's own document number still uses the `PRD` prefix via `DocumentTypes.Production` (`PRD-2026-00001`). + +--- + +## Part B — Requirements + +### B.1 Scope + +**In scope:** production **templates** designed on a canvas — a directed acyclic graph of stages, each with an input/output formula, role label, estimated time, custom fields, and stored layout; production **runs** instantiated from a template with auto-scaled, per-run-editable quantities; stage execution lifecycle (waiting → ready → in-progress → done → approved, with rejection/rework paths); real stock integration — FIFO consumption of stock inputs at stage start, internal WIP flow between stages, cost-rolled-up finished-goods receipt at the terminal stage; scrap, leftover return, and partial downstream transfer; run cancellation with stock return; run board listing with per-stage progress. + +**Out of scope (deferred, hooks retained):** role-based *enforcement* of the stage role label (label is informational this phase — FR-X-01 posture unchanged); machine/work-center capacity and scheduling; labor/overhead absorption into cost (cost = material roll-up only; a cost-component seam is noted in FR-MFG-19); co-products / multiple finished items per run (terminal stage has exactly one output item); template versioning (edit-lock replaces it, FR-MFG-06); production planning / MRP. + +### B.2 Definitions +Template = reusable production-line definition (the graph) · Stage = one box on the canvas · Edge = parent→child arrow · Entry stage = stage with no inbound edges · Terminal stage = the single stage with no outbound edges · Run = one execution instance of a template (`PRD-…`) · WIP = work-in-progress quantities flowing between run stages (internal, not stock) · Stock input = a stage input drawn from warehouse stock via FIFO · Upstream input = a stage input fed by a parent stage's output · Cost pool = Σ consumed stock value − Σ leftover returns, absorbed into the finished layer. + +### B.3 Functional requirements (FR-MFG) + +| ID | Requirement | Pri | +|---|---|---| +| FR-MFG-01 | Maintain **Production Templates**: code, name, description, status (Active/Inactive), and a stage graph. Deactivate — never hard-delete — once any run references the template (`MASTER_IN_USE` posture, FR-MD-08). | M | +| FR-MFG-02 | A template's stage graph is a **DAG** with **≥1 entry stage** and **exactly one terminal stage** (multiple starts converging to one end). Server validates on every save: no cycles, terminal count = 1, no disconnected stages, every non-entry stage reachable from an entry and reaching the terminal. | M | +| FR-MFG-03 | Each stage carries: name, **role label** (free text, e.g. "QA" — informational only this phase), **estimated minutes**, canvas position (`posX`,`posY` — stored, never interpreted server-side), a **formula** (inputs + outputs with quantities per batch), and **custom field definitions** (jsonb). | M | +| FR-MFG-04 | A stage **input** is either **Stock** (references an Item + UOM; FIFO-consumed from the run warehouse when the stage starts — allowed on *any* stage, e.g. packaging added late) or **Upstream** (references an output of a **direct parent** stage; flows as internal WIP, never touches the ledger). | M | +| FR-MFG-05 | A stage **output** is a named quantity (+UOM). **Intermediate outputs are internal WIP only** (`item_id` null — no stock, no ledger). The **terminal stage's output must reference a real Item** (the finished good) and there is exactly **one** terminal output. | M | +| FR-MFG-06 | **Edit-lock instead of versioning:** a template cannot be edited (PUT) while any run of it is in a non-final status (`InProgress`) → `409 TEMPLATE_IN_USE`. Editing is allowed again when all runs are `Completed`/`Cancelled`. Run rows copy display fields (name, role, estimated minutes, field defs, scaled quantities) at creation so completed-run history stays readable even if the template later changes. | M | +| FR-MFG-07 | **Custom fields:** field defs are jsonb on the template stage — `[{ key, label, type: Text\|Number\|Checkbox\|Date\|Select, options?, required }]`. Values are jsonb on the run stage, captured at **complete**; required fields must be present or complete is rejected (`400 REQUIRED_FIELD_MISSING`). | M | +| FR-MFG-08 | **Run creation:** `POST` with template, **target quantity** of the finished item, source **warehouse**, optional output bin. All formula quantities **auto-scale** by `targetQty / terminalOutputQtyPerBatch`; scaled planned quantities are copied to run rows and are **per-run editable** on any stage that has not yet started (in/out both). Doc no from `NumberSequence`: **`PRD-2026-00001`**. | M | +| FR-MFG-09 | **Stage readiness:** entry stages are `Ready` at run creation; every other stage is `Waiting` and becomes `Ready` only when **every** Upstream input has received delivered qty ≥ its planned qty (all-parents join, per-edge full delivery). | M | +| FR-MFG-10 | **Stage start** (`Ready → InProgress`): FIFO-consume all the stage's Stock inputs from the run warehouse in one transaction (existing blocks apply: `STOCK_NEGATIVE_BLOCKED`, `ONHOLD_NOT_ISSUABLE`, `EXPIRED_BATCH_BLOCKED`); record consumed qty + value per input; stamp `actualStartAt`. | M | +| FR-MFG-11 | **Stage complete** (`InProgress → Done`): record per output **produced qty**, **scrapped qty** (+ mandatory reason code when scrap > 0, context `Production`), and custom field values; stamp `actualEndAt`. Scrap cost is **absorbed** into the run cost pool (normal yield loss); no write-off ledger entry. | M | +| FR-MFG-12 | **Stage approve** (`Done → Approved`): non-terminal — transfers output WIP to children. Default transfers the full available produced qty per outbound edge; a **partial** transfer amount may be given, with the remainder held on the stage and transferable later via a dedicated transfer action (never exceeding produced − scrapped − already transferred → `422 TRANSFER_EXCEEDS_AVAILABLE`). | M | +| FR-MFG-13 | **Terminal approve = production receipt:** creates a **StockLayer** for the finished item at the run warehouse/output bin — qty = terminal good produced qty; **unit cost = run cost pool ÷ good qty** (material roll-up); posts an inbound ledger entry (`ProductionReceipt`); run → `Completed`. After receipt the cost pool is **closed**: no further leftover returns (`409 RUN_COST_CLOSED`). | M | +| FR-MFG-14 | **Leftover return (remaining-qty b):** unconsumed Stock-input quantity may be returned to stock before receipt: creates an inbound layer at the **weighted cost actually consumed** for that input (cost-preserving), ledger `ProductionReturn`, mandatory reason code; reduces the cost pool. Cannot exceed consumed − already returned (`422 LEFTOVER_EXCEEDS_CONSUMED`). | M | +| FR-MFG-15 | **Reject-intake (downstream reject):** a `Ready` stage may reject its received work → its delivering parent stage(s) revert `Approved → InProgress` (rework), their transferred quantities are pulled back onto the parent, and the rejecting stage returns to `Waiting`. The parent re-completes/re-approves; consumed stock stays consumed. | M | +| FR-MFG-16 | **Terminal reject (end-of-process reject):** rejecting at the terminal stage **resets the whole run to its start** — entry stages `Ready`, all others `Waiting`, all WIP transfer/produced figures cleared into a rework history snapshot, `reworkCount` +1. Already-consumed materials **remain in the cost pool** (no automatic re-consumption; if rework needs more material, edit planned Stock-input qty upward — the delta is consumed at that stage's next start). | M | +| FR-MFG-17 | **Run cancel:** allowed while `InProgress` → status `Cancelled` (mandatory reason code). Net consumed-and-not-returned stock quantities are **returned to stock via an adjustment-style inbound** at their consumed weighted cost (`ProductionCancelReturn` ledger entries); quantities already scrapped stay scrapped (their cost is written off with the cancel — recorded on the run, no GL posting this phase). `Completed` runs cannot be cancelled (`409 RUN_NOT_CANCELLABLE`). | M | +| FR-MFG-18 | **Run board:** list runs with doc no, template, target qty, status, rework count, timestamps, and a **per-status stage count summary** (`{waiting, ready, inProgress, done, approved}`) for progress display. | M | +| FR-MFG-19 | Track **estimated vs actual**: `estimatedMinutes` (copied from template) plus `actualStartAt`/`actualEndAt` per run stage. *(Seam: a future cost-component table can add labor/overhead to the cost pool without schema change to this phase's tables.)* | S | +| FR-MFG-20 | All mutations audit-stamped (actor from token `sub`), doc numbers sequential per year, statuses never client-settable (narrow DTOs, `02-SECURITY B.6`). | M | + +### B.4 Status machines + +**Run:** `InProgress → Completed | Cancelled` + +**Run stage:** +``` +Waiting ──(all upstream inputs fully delivered)──▶ Ready +Ready ──start (consume Stock inputs)──▶ InProgress +InProgress ──complete (produced/scrap/fields)──▶ Done +Done ──approve──▶ Approved ──(non-terminal: WIP transfers out; terminal: receipt, run Completed) + +Rework paths: +Ready ──reject-intake──▶ Waiting (and delivering parents: Approved ──▶ InProgress, transfers pulled back) +Terminal Done ──reject──▶ run reset (entries Ready, others Waiting, reworkCount+1) +``` +`Rejected` is not a resting state — a rejection immediately produces the rework transition above; the rejection event itself is recorded in the stage's history (who/when/note). + +--- + +## Part C — Entity model (authoritative) + +``` +PRODUCTION_TEMPLATE(template_id PK, code UQ, name, description, status, created_by FK→USER, created_at) + +TEMPLATE_STAGE(stage_id PK, template_id FK→PRODUCTION_TEMPLATE, name, role_label, + estimated_minutes, pos_x, pos_y, field_defs jsonb) + +STAGE_EDGE(edge_id PK, template_id FK→PRODUCTION_TEMPLATE, + parent_stage_id FK→TEMPLATE_STAGE, child_stage_id FK→TEMPLATE_STAGE) + -- UQ(parent_stage_id, child_stage_id); parent != child; DAG enforced in service + +STAGE_INPUT(input_id PK, stage_id FK→TEMPLATE_STAGE, source, -- Stock | Upstream + item_id FK→ITEM, -- required when Stock, null when Upstream + from_output_id FK→STAGE_OUTPUT, -- required when Upstream (must belong to a direct parent), null when Stock + uom_id FK→UOM, qty_per_batch) + +STAGE_OUTPUT(output_id PK, stage_id FK→TEMPLATE_STAGE, + item_id FK→ITEM, -- null on intermediate stages; REQUIRED on the terminal stage + name, uom_id FK→UOM, qty_per_batch) + -- terminal stage: exactly one output row + +PRODUCTION_RUN(run_id PK, doc_no UQ, template_id FK→PRODUCTION_TEMPLATE, + warehouse_id FK→WAREHOUSE, output_bin_id FK→BIN, + target_qty, scale_factor, status, rework_count, + cancel_reason_code_id FK→REASON_CODE, created_by FK→USER, created_at, completed_at) + +RUN_STAGE(run_stage_id PK, run_id FK→PRODUCTION_RUN, template_stage_id FK→TEMPLATE_STAGE, + name, role_label, estimated_minutes, -- copied at run creation (FR-MFG-06) + status, actual_start_at, actual_end_at, + field_defs jsonb, field_values jsonb) + +RUN_STAGE_INPUT(run_input_id PK, run_stage_id FK→RUN_STAGE, source, + item_id FK→ITEM, from_run_output_id FK→RUN_STAGE_OUTPUT, uom_id FK→UOM, + planned_qty, -- scaled at creation, editable until stage start + consumed_qty, consumed_value, -- Stock inputs: set at start + delivered_qty, -- Upstream inputs: accumulated by parent transfers + returned_qty, returned_value) -- leftover returns (FR-MFG-14) + +RUN_STAGE_OUTPUT(run_output_id PK, run_stage_id FK→RUN_STAGE, + item_id FK→ITEM, name, uom_id FK→UOM, + planned_qty, produced_qty, scrapped_qty, + scrap_reason_code_id FK→REASON_CODE, transferred_qty) + -- available-to-transfer = produced_qty − scrapped_qty − transferred_qty (derived, never stored) + +RUN_STAGE_EVENT(event_id PK, run_id FK→PRODUCTION_RUN, run_stage_id FK→RUN_STAGE [nullable], + event_type, -- Start|Complete|Approve|Transfer|RejectIntake|TerminalReject|LeftoverReturn|Cancel|QuantityEdit + note, payload jsonb, user_id FK→USER, created_at) -- immutable history incl. rework snapshots + +RUN_EDGE(run_edge_id PK, run_id FK→PRODUCTION_RUN, + parent_run_stage_id FK→RUN_STAGE, child_run_stage_id FK→RUN_STAGE) + -- UQ(parent_run_stage_id, child_run_stage_id); copied from STAGE_EDGE at run creation +``` + +> **AS BUILT — three additions to this model, all load-bearing:** +> +> 1. **`RUN_EDGE` (new table).** The doc had no run-edge table, but the run graph needs its own copy for the read-only canvas, child-readiness evaluation and reject-intake's "delivering parents". Deriving edges at read time through `RUN_STAGE.template_stage_id → STAGE_EDGE` would let a later template `PUT` silently rewrite a *completed* run's shape — exactly what FR-MFG-06 exists to prevent — and breaks outright once that link is nulled (see 3 below). +> 2. **`RUN_STAGE.pos_x` / `pos_y`.** `21-FRONTEND-PHASE2 §5` renders the run canvas from "positions from the run's copied stages", but `RUN_STAGE` had no position columns. +> 3. **`RUN_STAGE_EVENT.run_id`, and `run_stage_id` made nullable.** Run-level events (cancel) have no stage to hang off, and the run-detail timeline becomes one ordered query instead of a join through stages. +> +> **Also as built: `RUN_STAGE.template_stage_id` is nullable with `ON DELETE SET NULL`.** The edit-lock only blocks a template `PUT` while a run is `InProgress`, so `Completed`/`Cancelled` runs still hold that FK — under `RESTRICT` a stage deletion would fail forever, making templates progressively un-editable. Every display field is already copied onto the run row (FR-MFG-06), so losing the provenance link is the intended trade rather than a loss. +> +> **`is_terminal` / `is_entry` are never stored** on `RUN_STAGE` — both are derived from the run edge set and surfaced as computed DTO fields, so they cannot drift from it. + +> **AS BUILT — a fourth addition, made when the builder was wired: `PRODUCTION_TEMPLATE.annotations` (jsonb, nullable).** +> +> The builder canvas already supported free-floating **grouping boxes and divider lines** — annotations with no ports, no edges and no graph semantics — and this model had nowhere to keep them, so every save would have silently discarded the user's layout notes. Silent data loss is worse than either deleting the feature or storing a little opaque client state, so the column exists. +> +> Shape: an array of `{ kind: "box"|"line", posX, posY, width, height, label?, rotation? }`, written through `ProductionJson` like every other jsonb column (canonical JSON only, never the raw client string), capped at 200 entries, with `kind` validated server-side because nothing else constrains free-form state going into jsonb. `ProductionGraphValidator` never sees it. +> +> **Replacement is wholesale** — like `STAGE_INPUT`/`STAGE_OUTPUT` and unlike stages, since nothing references an annotation. The consequence is a contract obligation on the client: a `PUT` that omits `annotations` **clears** them, so a caller echoing a fetched graph back must echo these too. Pinned by an explicit preserve → clear → restore assertion in `m2_templates.py`. + +**Costing invariants:** run cost pool = Σ `consumed_value` − Σ `returned_value` across all run-stage inputs. Terminal receipt `unit_cost = cost_pool / good_qty` (rounded to cost precision; remainder absorbed into the layer value so Σ ledger value is exact). No stock/ledger row is ever written for Upstream (WIP) movements. + +--- + +## Part D — API contract + +Base conventions identical to Phase 1 (`11-BACKEND-PHASE1 §1`): versioned base path, paging envelope, `ProblemDetails` errors, ETag/`If-Match` on mutable resources, `Idempotency-Key` honored on stage-transition posts. + +### D.1 Templates + +#### `GET /production-templates` +Query: `q`, `status`, + paging → list envelope of +`{ templateId, code, name, status, stageCount, activeRunCount, createdBy, createdAt }`. + +#### `GET /production-templates/{id}` → full graph +```json +{ "templateId": 7, "code": "PT-CHAIR", "name": "Wooden chair line", "status": "Active", + "stages": [ + { "stageId": 21, "name": "Cut frame", "roleLabel": "Carpentry", "estimatedMinutes": 60, + "posX": 80, "posY": 120, + "fieldDefs": [ { "key": "moisture_ok", "label": "Moisture check", "type": "Checkbox", "required": true } ], + "inputs": [ { "inputId": 61, "source": "Stock", "itemId": 1001, "uomId": 3, "qtyPerBatch": 8 } ], + "outputs": [ { "outputId": 91, "itemId": null, "name": "Frame set", "uomId": 5, "qtyPerBatch": 1 } ] }, + { "stageId": 24, "name": "Assemble & QA", "roleLabel": "QA", "estimatedMinutes": 45, + "posX": 560, "posY": 200, "fieldDefs": [], + "inputs": [ { "inputId": 66, "source": "Upstream", "fromOutputId": 91, "uomId": 5, "qtyPerBatch": 1 }, + { "inputId": 67, "source": "Stock", "itemId": 1044, "uomId": 3, "qtyPerBatch": 12 } ], + "outputs": [ { "outputId": 95, "itemId": 2001, "name": "Chair", "uomId": 5, "qtyPerBatch": 1 } ] } ], + "edges": [ { "edgeId": 11, "parentStageId": 21, "childStageId": 24 } ] } +``` + +#### `POST /production-templates` · `PUT /production-templates/{id}` +Full-graph payload (same shape as GET, without ids on POST; PUT replaces the graph, requires `If-Match`). +- `409 TEMPLATE_IN_USE` — PUT while any run is `InProgress` (FR-MFG-06). +- `422 GRAPH_CYCLE` · `422 GRAPH_TERMINAL_COUNT` (≠1 terminal) · `422 GRAPH_DISCONNECTED` · `422 GRAPH_INPUT_SOURCE_INVALID` (Upstream input not fed by a direct parent's output) · `422 TERMINAL_OUTPUT_ITEM_REQUIRED`. + +#### `PATCH /production-templates/{id}/status` `{ "status": "Inactive" }` → 204. Inactive templates cannot start new runs. + +> **AS BUILT — §D.1 additions, all driven by what the canvas actually needs:** +> +> - **The list row also carries `stageNames`, in flow order.** The template overview draws every template as a production line with its stages left to right (`21-FRONTEND-PHASE2 §1`); without the names on the list row, labelling *n* rows would take *n* extra graph fetches. Ordering by `stageId` turned out to be insertion order, which routinely puts the **terminal** stage first and draws the line backwards, so the server toposorts (Kahn, tie-broken by id so parallel branches are stable, falling back to id order if the graph is ever cyclic so a listing can never fail on bad data). +> - **The graph response also carries `activeRunCount`** — the same figure the list row has, and the one that puts the builder into its edit-locked state. Without it the builder would have to call the list endpoint purely to decide whether to disable itself. +> - **The graph response also carries `annotations`,** and `POST`/`PUT` accept them. See the `PRODUCTION_TEMPLATE.annotations` note in Part C, including the obligation to echo them back. +> - **Stages and outputs carry a client-facing `key` alongside their id, and edges/Upstream inputs reference *keys*.** On a GET the key is the stringified id; on a save the client echoes it back for rows it kept and mints `tmp-` for rows it drew. One payload shape and one validator therefore serve both POST (nothing has an id) and PUT (most things do), and a recognised stage key is diffed **in place** so `RUN_STAGE.template_stage_id` stays valid for historical runs. The builder uses the key as its React Flow node id, which is why `parentKey`/`childKey` need no translation on save. +> - **`PATCH /status` is never edit-locked.** Deactivating is the FR-MFG-01 path and only blocks *new* runs, so it stays available while runs are in flight — unlike `PUT`. Note it bumps the row's `xmin` and therefore invalidates any ETag the caller is holding. + +### D.2 Runs + +#### `GET /production-runs` +Query: `q`, `status` (`InProgress|Completed|Cancelled`), `templateId`, `warehouseId`, + paging. Newest first. → list envelope of +```json +{ "runId": 501, "docNo": "PRD-2026-00001", "templateId": 7, "templateName": "Wooden chair line", + "targetQty": 50, "status": "InProgress", "reworkCount": 0, + "stageSummary": { "waiting": 1, "ready": 0, "inProgress": 1, "done": 0, "approved": 1 }, + "createdBy": 17, "createdAt": "2026-07-28T08:00:00Z", "completedAt": null } +``` + +#### `POST /production-runs` +```json +{ "templateId": 7, "targetQty": 50, "warehouseId": 1, "outputBinId": 90 } +``` +**201 Created** — run with all stages copied + quantities scaled (`scaleFactor = targetQty / terminalOutputQtyPerBatch`); entry stages `Ready`, others `Waiting`. `422 TEMPLATE_INACTIVE` if template is Inactive. + +#### `GET /production-runs/{id}` → full run graph: every run stage with status, planned/actual quantities per input & output, `deliveredQty`, timestamps, `fieldDefs`/`fieldValues`, edges, and event history. + +#### `PUT /production-runs/{id}/stages/{sid}/quantities` +```json +{ "inputs": [ { "runInputId": 301, "plannedQty": 420 } ], + "outputs": [ { "runOutputId": 401, "plannedQty": 52 } ] } +``` +Per-run scaling override (FR-MFG-08). `409 STAGE_NOT_EDITABLE` once the stage has started. Raising a Stock input's planned qty after a rework start consumes only the delta at next start (FR-MFG-16). + +### D.3 Stage actions +All are `POST /production-runs/{id}/stages/{sid}/…`, transactional, and return the refreshed run stage (plus any stock effects). + +> **AS BUILT — clarifications and deviations, all verified by `Backend/smoke/`:** +> +> - **`Idempotency-Key` is accepted and ignored**, matching the Phase-1 posture exactly (`GrnsController` takes the header, `GrnService.ConfirmAsync` ignores it). Replay safety comes from the status guards this section already specifies: a double-fire finds the stage already moved on and gets a `409`, which `21-FRONTEND-PHASE2 §6` already tells the client to treat as a silent refetch. No key store was built. `RunStage` additionally carries an `xmin` `RowVersion` so two genuinely concurrent terminal approves cannot both read `Done` and post two receipts. +> - **UOM conversion on Stock inputs.** Not mentioned anywhere in this doc, but `STAGE_INPUT.uom_id` is a free FK while the FIFO engine works exclusively in the item's **base** UOM. All consumption therefore converts through the shared `IUomConverter` (extracted from `GrnService.ToBaseAsync`). Consequence for the contract: **`plannedQty` is in the input's declared UOM, while `consumedQty`/`consumedValue`/`returnedQty`/`returnedValue` are in the item's base UOM.** An input whose UOM has no conversion defined for the item is refused with `422`, never assumed 1:1. +> - **Transfers route by input, not by edge.** FR-MFG-12 says "per outbound edge", but the model connects an output to a specific *input* (`RUN_STAGE_INPUT.from_run_output_id`): an edge can exist with no input drawing from it, and one output can feed inputs on several children. Delivery therefore routes by `fromRunOutputId`; `RUN_EDGE` is display and validation only. When one output feeds several inputs and no explicit target is given, they fill in `runInputId` order up to each one's outstanding need with any overflow to the last; the request accepts an optional `runInputId` to remove the ambiguity. +> - **A re-complete overwrites, it does not accumulate.** Completing a stage that already has `producedQty > 0` (a rework re-complete) *replaces* the figures. Adding would double the produced quantity on every rework pass. A re-complete that would drop the good quantity below what has already been transferred is refused with `422 TRANSFER_EXCEEDS_AVAILABLE`. +> - **Start consumes only the delta.** Every start consumes `max(0, plannedBase − consumedQty)`. A rework restart with an unchanged planned quantity therefore makes **no FIFO call at all**, and one after a raise consumes only the increase. This is what makes FR-MFG-16's "edit planned Stock-input qty upward" work. +> - **Quantity edits re-evaluate readiness.** Raising a child's Upstream `plannedQty` after it went `Ready` demotes it back to `Waiting`. Not stated here; it is the only behaviour consistent with FR-MFG-09. +> - **Batch/serial-tracked finished goods are refused** with `422`. This doc defines no batch or serial creation on receipt, so a tracked finished item has no valid path; failing loudly beats silently receiving untracked stock. +> - **`GRAPH_DISCONNECTED` is unreachable in practice** and kept only as defence in depth: once the cycle and terminal-count checks pass, an acyclic graph with exactly one sink necessarily has every stage reachable from a source and reaching that sink. An isolated stage surfaces as `GRAPH_TERMINAL_COUNT` instead — the better message, since it names both offenders. + +#### `…/start` → `Ready → InProgress` +**200** `{ runStageId, status: "InProgress", actualStartAt, consumed: [ { runInputId, itemId, qty, value, consumedLayers: [...] } ], ledgerRefs: [...] }` +`409 STAGE_NOT_READY` · `409 STOCK_NEGATIVE_BLOCKED` · `409 ONHOLD_NOT_ISSUABLE` · `409 EXPIRED_BATCH_BLOCKED`. + +#### `…/complete` → `InProgress → Done` +```json +{ "outputs": [ { "runOutputId": 401, "producedQty": 50, "scrappedQty": 2, "scrapReasonCodeId": 12 } ], + "fieldValues": { "moisture_ok": true } } +``` +`400 REQUIRED_FIELD_MISSING` · `400 REASON_CODE_REQUIRED` (scrap > 0 without reason) · `409 STAGE_NOT_IN_PROGRESS`. + +#### `…/approve` → `Done → Approved` +Optional body for partial transfer: `{ "transfers": [ { "runOutputId": 401, "qty": 30 } ] }` (default = full available per outbound edge). +Non-terminal **200**: `{ status: "Approved", transfers: [ { edge, runOutputId, qty, childDeliveredQty } ] }` — children whose every upstream input reaches planned qty flip `Waiting → Ready`. +**Terminal** **200**: production receipt — +```json +{ "status": "Approved", "runStatus": "Completed", + "receipt": { "layerId": 9100, "itemId": 2001, "warehouseId": 1, "binId": 90, + "qtyReceived": 50, "unitCost": 21.38, "value": 1069.00 }, + "costPool": { "consumed": 1101.00, "returned": 32.00, "net": 1069.00 }, + "ledgerRefs": [ 61022 ] } +``` +`422 TRANSFER_EXCEEDS_AVAILABLE` · `409 STAGE_NOT_DONE`. + +#### `…/transfer` — later partial transfer of held remainder (remaining-qty c) +`{ "runOutputId": 401, "qty": 20 }` → **200** with updated `transferredQty` + child readiness. Only from `Approved` stages; `422 TRANSFER_EXCEEDS_AVAILABLE`. + +#### `…/reject-intake` — downstream reject (FR-MFG-15) +`{ "note": "Frames warped" }` → **200**: this stage `Waiting`, delivering parents `Approved → InProgress` with pulled-back `transferredQty`/child `deliveredQty`; event logged. `409 STAGE_REJECT_INVALID` if the stage has no delivered intake. + +> **AS BUILT — allowed from `Ready` *or* `Waiting`.** This section said `Ready` only, while `21-FRONTEND-PHASE2 §5` offers the action on "a Ready/Waiting stage with deliveries". The frontend reading is the correct one — a *partially* delivered stage is still `Waiting` and is exactly the case a user needs to reject — so the guard is on **delivered intake > 0**, not on the status. Reconciled in both docs. +> +> **The parent's `transferredQty` is decremented, never zeroed.** The parent may also have delivered to a *different* child; on its re-approve, `available = produced − scrapped − transferred` must still account for that other delivery. `ActualStartAt` is **preserved** (the original start stands, FR-MFG-19); only `ActualEndAt` is cleared. + +#### `…/reject` — terminal reject (FR-MFG-16), terminal stage only +`{ "note": "Final QA failed batch" }` → **200**: run reset (entries `Ready`, others `Waiting`), `reworkCount` incremented, prior figures snapshotted into `RUN_STAGE_EVENT`. Consumed stock unaffected. Allowed **only from `Done`** — approving the terminal completes the run and closes the cost pool, so there is no path back from `Approved`. + +> **AS BUILT — exactly what resets and what survives.** Getting either column wrong silently corrupts the cost pool, so it is enumerated: +> +> | Field | Reset? | +> |---|---| +> | `PRODUCTION_RUN.rework_count` | **+1** | +> | `PRODUCTION_RUN.status` / `completed_at` | no — stays `InProgress` / null | +> | `RUN_STAGE.status` | **yes** — entries `Ready`, all others `Waiting` | +> | `RUN_STAGE.actual_start_at` / `actual_end_at` / `field_values` | **yes → null** | +> | `RUN_STAGE.field_defs` / `name` / `role_label` / `estimated_minutes` / `pos_x` / `pos_y` / `template_stage_id` | no | +> | `RUN_STAGE_OUTPUT.produced_qty` / `scrapped_qty` / `scrap_reason_code_id` / `transferred_qty` | **yes → 0 / null** | +> | `RUN_STAGE_INPUT.delivered_qty` | **yes → 0** (the WIP is gone) | +> | `RUN_STAGE_*.planned_qty` | **no** — per-run edits must survive; FR-MFG-16 expects them to be *raised* for the rework | +> | `RUN_STAGE_INPUT.consumed_qty` / `consumed_value` / `returned_qty` / `returned_value` | **no** — already-consumed material stays in the cost pool | +> | Stock layers / ledger rows | **untouched** — no reversal entries | +> +> One `TerminalReject` event per pass carries the whole pre-reset snapshot (not one row per stage), so "what did rework #2 look like" is a single read. + +#### `POST /production-runs/{id}/inputs/{runInputId}/return-leftover` (remaining-qty b) +`{ "qty": 5, "reasonCodeId": 14 }` → **200** `{ returnedQty, returnedValue, createdLayer: { layerId, unitCost }, ledgerRefs }` — inbound at consumed weighted cost. +`422 LEFTOVER_EXCEEDS_CONSUMED` · `409 RUN_COST_CLOSED` (after terminal receipt) · `400 REASON_CODE_REQUIRED`. + +#### `POST /production-runs/{id}/cancel` +`{ "reasonCodeId": 15, "note": "Order cancelled" }` → **200** `{ status: "Cancelled", returns: [ { itemId, qty, unitCost, layerId } ], scrappedWrittenOff: [ { runOutputId, name, qty } ], ledgerRefs }` (FR-MFG-17). +`409 RUN_NOT_CANCELLABLE` if `Completed` or already `Cancelled`. + +> **AS BUILT — "net consumed − returned − scrapped" is not computable as written.** `ScrappedQty` lives on **outputs**, in output UOM, and there is no per-input scrap anywhere in the model, so scrap cannot be deducted from an input return. Physically the doc's intent is already met: scrap is recorded against outputs (finished or intermediate WIP) which **never entered stock**, so there is nothing to deduct. As built, the cancel returns `consumedQty − returnedQty` per Stock input at its consumed weighted cost (value = the exact `consumedValue − returnedValue` residual, so the pool nets to zero), and records the scrapped output quantities on the cancel event as `scrappedWrittenOff`. `completedAt` stays null — a cancelled run never completed. + +### D.4 Error catalog additions +| Code | HTTP | When | +|---|---|---| +| `TEMPLATE_IN_USE` | 409 | Template edit while a run is InProgress. | +| `TEMPLATE_INACTIVE` | 422 | Run creation from an Inactive template. | +| `GRAPH_CYCLE` / `GRAPH_TERMINAL_COUNT` / `GRAPH_DISCONNECTED` / `GRAPH_INPUT_SOURCE_INVALID` / `TERMINAL_OUTPUT_ITEM_REQUIRED` | 422 | Graph validation on template save. | +| `STAGE_NOT_READY` / `STAGE_NOT_IN_PROGRESS` / `STAGE_NOT_DONE` / `STAGE_NOT_EDITABLE` / `STAGE_REJECT_INVALID` | 409 | Action fired against the wrong stage status. | +| `REQUIRED_FIELD_MISSING` | 400 | Complete without a required custom field value. | +| `TRANSFER_EXCEEDS_AVAILABLE` | 422 | Transfer > produced − scrapped − transferred. | +| `LEFTOVER_EXCEEDS_CONSUMED` | 422 | Leftover return > consumed − already returned. | +| `RUN_COST_CLOSED` | 409 | Leftover return after terminal receipt. | +| `RUN_NOT_CANCELLABLE` | 409 | Cancel on a Completed run. | +Reused from Phase 1: `STOCK_NEGATIVE_BLOCKED`, `ONHOLD_NOT_ISSUABLE`, `EXPIRED_BATCH_BLOCKED`, `REASON_CODE_REQUIRED`, `CONCURRENCY_CONFLICT`, `IDEMPOTENCY_REPLAY`, `MASTER_IN_USE`. + +### D.5 Enumerations +| Enum | Values | +|---|---| +| Template `status` | `Active`, `Inactive` | +| Run `status` | `InProgress`, `Completed`, `Cancelled` | +| Run-stage `status` | `Waiting`, `Ready`, `InProgress`, `Done`, `Approved` | +| `stageInputSource` | `Stock`, `Upstream` | +| Custom `fieldType` | `Text`, `Number`, `Checkbox`, `Date`, `Select` | +| `ReasonContext` (extended) | + `Production` | +| Ledger `source_doc_type` (extended) | + `ProductionIssue`, `ProductionReceipt`, `ProductionReturn`, `ProductionCancelReturn` | + +--- + +## Part E — Implementation order (PROGRESS seed) +1. Enum extensions + `STOCK_LAYER.grn_line_id` nullable migration (shared deviation, A.1) +2. Template entities + graph validator + `/production-templates` CRUD +3. Run creation (scaling, copy-on-create, numbering) + run list/detail +4. Stage start (FIFO consume) → complete → approve (transfers, readiness) +5. Terminal receipt + cost pool +6. Remaining-qty trio: scrap (in complete), leftover return, partial transfer +7. Reject-intake + terminal reject (rework) + run cancel +8. Event history + estimated-vs-actual surfacing + +> **AS BUILT — all eight steps complete and smoke-verified (see `Backend/PROGRESS.md`).** Step 1 turned out to be a no-op (§A.1). The 11 tables shipped as one migration, `AddManufacturingPhase2`, because the entities are mutually FK-referential and would not compile split across migrations. Steps 4 and 5 are one method (`ApproveStageAsync` branches on terminal) but were verified as separate gates. +> +> Verification lives in `Backend/smoke/*.py` — re-runnable scripts, one per milestone, against local Postgres with a real AuthHex session. Three invariants are asserted directly against the ledger: +> 1. `Σ PRDI.value − Σ PRDL.value == PRDR.value` for a completed run; +> 2. a *full* leftover return leaves `returnedValue == consumedValue` exactly; +> 3. after a cancel, `Σ PRDC.value == Σ (consumedValue − returnedValue)` and on-hand is restored. + +*End of 30-BACKEND-PHASE2.md. Frontend consumption: `21-FRONTEND-PHASE2.md`. Record work: `Backend/PROGRESS.md`.*