QR Scanning

​

Overview

​

QR Code Format

STDPLUS:PNE-0001

​

Workflow

​

Standard Panes

┌─────────┐    ┌─────────┐    ┌─────────┐    ┌───────┐
│ cutting │───▶│ edging  │───▶│   qc    │───▶│ ready │
└─────────┘    └─────────┘    └─────────┘    └───────┘

1. Panes start at their first routing station (e.g. cutting) with status pending. If routing is empty ([]), currentStation is null and the pane is already completed (nothing to scan).
2. At each station, workers can perform these actions (see Scan a pane for the full request body):
   • scan_in — Sets currentStation to the station, currentStatus to in_progress, and startedAt (if not already set).
   • start — Sets currentStation to the station and currentStatus to in_progress.
   • complete — Sets currentStation to the station and currentStatus to awaiting_scan_out.
   • scan_out — Handoff: requires status awaiting_scan_out. Advances the pane to the next station with status pending. If it’s the last station, pane becomes completed.
   • qc_pass — Same rules as scan_out (must be awaiting_scan_out at the given station). Use at a QC station to record a QC pass in PaneLog (action: "qc_pass") while moving the pane forward or completing it.
   • qc_fail — Requires awaiting_scan_out at the station. Marks the pane defected (it must not be scanned again for production), writes a PaneLog with reason and optional description, and automatically creates a remake pane (remakeOf → failed pane) with status pending at the first routing station (or at remakeStationId if you pass it). See QC fail and remake below.
3. After the last station’s scan_out or qc_pass, the pane is marked completed with completedAt set.

​

Laminate Panes

Request (sheetsPerPane: 2)
  └─ PNE-0100     (parent, laminateRole: "parent", dormant until merge)
  └─ PNE-0100-A   (sheet,  laminateRole: "sheet")
  └─ PNE-0100-B   (sheet,  laminateRole: "sheet")

• Child sheets get the pre-laminate segment of routing (up to and including the lamination station)
• Parent pane row holds post-lamination routing only (qc, delivery, …); it stays dormant (currentStation: null, not printed on a shop QR) until merge retires it

Sheet A:  cutting → … → lamination ─┐
                                      ├─ laminate → one survivor (e.g. PNE-0100-A): lamination (awaiting_scan_out) → scan_out / qc_pass → qc → …
Sheet B:  cutting → … → lamination ─┘   (other sheet + parent row → merged_into; scan survivor’s QR only)

• The system checks if all active siblings (not claimed, not merged_into) are present
• Emits laminate:ready when all sheets are at the station, or laminate:waiting with a progress count

​

Two-Step Completion Flow

scan_in → start → complete (awaiting_scan_out) → scan_out (moves to next station)

• complete confirms the worker finished their task but the pane hasn’t left the station yet.
• scan_out is the physical handoff — the pane moves to the next station (or is marked completed if it was the last one).
• qc_pass is an alternative to scan_out when you want the audit log to show a QC pass; behavior for routing and order progress is the same.
• qc_fail ends the line for this physical pane and triggers a remake (see below).

​

QC fail and auto-remake

1. The pane must be at awaiting_scan_out and the request station must match currentStation (same as scan_out).
2. reason is required. Allowed values: broken, chipped, dimension_wrong, scratch, stain, other.
3. description is optional (extra text stored on the PaneLog).
4. remakeStationId is optional. If omitted, the new pane is queued at the first station in routing (or the order’s station list). If set, the remake starts at that station instead.
5. The current pane becomes defected with currentStation: null — treat it as scrap for workflow purposes; do not scan it through production again.
6. A new pane is created with remakeOf pointing at the defected pane, same order/request/material/routing copy rules as other remakes, pending at the chosen first station.
7. For non–sheet panes, the order’s paneCount increases by 1 so progress still reflects the extra unit of work. Sheet panes follow the same counting rules as elsewhere (sheets are excluded from certain order counters).

​

Mobile Scanning Flow

​

Batch Scanning

POST /api/panes/batch-scan
{
  "paneNumbers": ["PNE-0001", "PNE-0002", "PNE-0003"],
  "station": "<station-id>",
  "action": "scan_in"
}

• Actions: scan_in, start, and complete only — same semantics per pane as the single-pane scan API for those actions.
• Order: Panes are processed in paneNumbers order. Unknown or duplicate numbers are skipped; if none match, the API returns 400.
• Consistency: If any pane in the batch fails validation partway through, the server rolls back earlier changes in that same request (pane fields restored, PaneLog rows from that batch removed). This uses application-level rollback, not MongoDB transactions, so it works on standalone MongoDB without a replica set.
• Not in batch: scan_out, qc_pass, qc_fail, and laminate — call POST /api/panes/{paneNumber}/scan per pane for those.

​

Laminate Merge

POST /api/panes/PNE-0100-A/scan
{
  "station": "<lamination-station-id>",
  "action": "laminate"
}

1. Validates all active sheets (!= claimed, != merged_into) are present at the lamination station
2. Survivor — one sheet stays active: laminateRole becomes single, routing becomes the post-lamination route, awaiting_scan_out at the lam station, laminateMergedAt set; same paneNumber / QR as that sheet
3. Retired — other sheets and the dormant parent row → currentStatus: merged_into, mergedInto → survivor
4. First scan_out / qc_pass from lamination uses survivor routing (lam station is not in that array) → moves to first post-lam station (e.g. QC). The survivor’s laminateMergedAt flag is used for that handoff only, then cleared so later stations use normal routing index rules.
5. PaneLog: laminate_complete on retired sheets and parent, laminate_start on the survivor
6. order.stationBreakdown updated (sheets at lam consolidated to one unit)
7. Emits pane:laminated (payload includes survivor, parent alias, retiredPaneNumbers, sheets, parentPaneNumber)

• pane — the survivor pane
• mergedSheets, survivorPaneNumber, retiredPaneNumbers, parentRetired

​

Side Effects

​

WebSocket Events

​

Listening for Scan Events

import { io } from 'socket.io-client';

const socket = io('http://localhost:3000', {
  path: '/api/socket-entry',
  auth: { token: 'your-jwt-token' },
});

socket.on('connect', () => {
  socket.emit('join_pane');
  socket.emit('join_production');
  socket.emit('join_station');
  socket.emit('join_me');
});

socket.on('pane:updated', ({ action, data }) => {
  console.log('Pane changed:', data.paneNumber, data.currentStation);
});

socket.on('station:pane_arrived', ({ paneNumber, fromStation, toStation }) => {
  console.log(`${paneNumber} moved from ${fromStation} to ${toStation}`);
});

socket.on('notification', (notif) => {
  console.log(`[${notif.priority}] ${notif.title}: ${notif.message}`);
});

// Laminate pairing events
socket.on('laminate:ready', ({ parentPaneNumber, sheetsPresent, sheetsTotal }) => {
  console.log(`All ${sheetsTotal} sheets ready for ${parentPaneNumber} — merge now`);
});

socket.on('laminate:waiting', ({ parentPaneNumber, sheetsPresent, sheetsTotal }) => {
  console.log(`${sheetsPresent}/${sheetsTotal} sheets arrived for ${parentPaneNumber}`);
});

socket.on('pane:laminated', ({ survivor, parent, sheets, retiredPaneNumbers }) => {
  const live = survivor || parent;
  console.log(`Survivor ${live.paneNumber}; retired: ${(retiredPaneNumbers || []).join(', ')}; sheets: ${(sheets || []).join(', ')}`);
});

​

Error Handling