spencermandClaude Fable 5.1
5a4174e0c2
The shop at parity with the old build. Supervisor screen (department chips, CO headline, numbers, Change orders
on hold, station grid with clocks and CO tags, boards) and Stall screen (station picker, hero, My packets,
Submitted). Shop steps on the packet page: assign with station, welder picker and stamp; pull back; Start, Pause,
Resume; Submit with a PIN signature and the missing steps as links; review with Send to Q.C., Return to station
and Skip Q.C. route; a lead's read-only review. Weld map (pdf.js viewer with pan, pinch, zoom, full screen; marks
with leader lines; weld sheet; weld record with field CAS; carried marks). Heat map (heat table placed, dragged,
sized, removed; legacy amber tags; borrowed heat map read-only). Checklist tab with templates from settings.
VOID stamps on voided pages. Change orders: CO-n labels, supervisor verify with signature, approval copies the
heat table to the new sheet and the BOM merge keeps the shop's values. Server clock of record with VISUAL ticket
hours beside it. Presence per packet over SSE. Migration 0006 (bfx, bfy, carried_from, checklist_templates).
New endpoints /api/shop/board, /api/shop/stations, /api/shop/stall, /api/departments/{code}/people.
Tests: policy oracle for every shop action, role and status; clock arithmetic; concurrent inserts; CO apply;
frontend geometry, heat table, clock, checklist, weld sheet, screens; seven Playwright scenarios. Docs updated.
Co-Authored-By: Claude Fable 5.1 <[email protected]>
831 lines
32 KiB
Python
831 lines
32 KiB
Python
"""The write pipeline: every packet write is one transaction through `packet_write`.
|
||
|
||
Inside one transaction: lock the packet row (SELECT ... FOR UPDATE), build the policy's PacketState, check the
|
||
caller's expected step (409 stale_step), check the packet version when If-Match is given (409 version_conflict),
|
||
ask the policy (403 or 400 with the decision's code), take the signature when the rule needs one, hand the caller a
|
||
`Write`, then bump the version, write the packet_log row, the transition row and its side effects, the audit row and
|
||
the NOTIFY. The policy decides; a handler never does.
|
||
|
||
A wrong signature secret is the one failure that commits: the step-up failure count and the attempt row must stay,
|
||
so the three-strike rule works. Nothing else has been written at that point.
|
||
|
||
Child-row endpoints build on the same pieces: `check_row_version`, `next_counter`, `apply_field_cas`, `parse_if_match`.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import hashlib
|
||
import hmac
|
||
import logging
|
||
from collections.abc import Iterator, Mapping, Sequence
|
||
from contextlib import contextmanager
|
||
from dataclasses import dataclass, field
|
||
from typing import Any, Literal
|
||
|
||
from fastapi import Request
|
||
from psycopg.types.json import Jsonb
|
||
from pydantic import BaseModel, Field
|
||
|
||
from .. import audit, events, policy
|
||
from ..api import deps
|
||
from ..api.errors import ApiError
|
||
from ..auth import signatures
|
||
from ..auth.signatures import Signature
|
||
from ..policy.engine import MSG_FILED
|
||
from ..settings import SecretFileError
|
||
from ..text import LIMITS, clean_opt, reason_ok
|
||
from . import packets
|
||
|
||
log = logging.getLogger(__name__)
|
||
|
||
A = policy.Action
|
||
|
||
MSG_STALE = "Someone else already took this step."
|
||
MSG_VERSION = "The packet changed since you opened it. Reload and try again."
|
||
MSG_ROW = "Someone else changed this line. Reload and try again."
|
||
MSG_FIELD = "Someone else changed this since you opened it."
|
||
|
||
# Codes that answer 400 (the UI asks for input and retries); every other refusal answers 403.
|
||
ASK_CODES = frozenset({"it_reason_required", "reason_required"})
|
||
|
||
COUNTERS = {"weld": "next_weld_no", "heat": "next_heat_no", "page": "next_page_no", "co": "next_co_no"}
|
||
|
||
# The packet_log label per action, when the caller gives none.
|
||
LABELS: dict[policy.Action, str] = {
|
||
A.SEND_TO_WAREHOUSE: "Sent to warehouse",
|
||
A.RELEASE_TO_SHOP: "Sent straight to the shop",
|
||
A.SEND_DRAFT_TO_QC: "Sent straight to Q.C.",
|
||
A.WH_SEND_BACK: "Sent back to Clerical",
|
||
A.RETURN_TO_CLERICAL: "Sent back to Clerical",
|
||
A.WH_RELEASE: "Released to supervisor",
|
||
A.SEND_BACK_TO_WAREHOUSE: "Sent back to the warehouse",
|
||
A.ASSIGN: "Sent to a station",
|
||
A.UNASSIGN: "Taken off the station",
|
||
A.PULL_BACK: "Pulled back from the station",
|
||
A.START: "Work started",
|
||
A.SUBMIT: "Submitted to supervisor",
|
||
A.RETURN_TO_STATION: "Returned to the station",
|
||
A.SEND_TO_QC: "Sent to Q.C.",
|
||
A.ROUTE_FROM_REVIEW: "Routed to another department",
|
||
A.QC_REJECT: "Q.C. rejected",
|
||
A.QC_ACCEPT: "Q.C. accepted",
|
||
A.QC_ACCEPT_AND_ROUTE: "Q.C. accepted and routed",
|
||
A.FILE: "Filed in the data book",
|
||
A.ADMIN_REOPEN: "Reopened by IT",
|
||
A.EDIT_HEADER: "Details changed",
|
||
A.EDIT_DRAWING_REF: "Drawing number changed",
|
||
A.EDIT_DEPT: "Department changed",
|
||
A.MOVE_UNIT: "Moved to another unit",
|
||
A.EDIT_WOS: "Work orders changed",
|
||
A.EDIT_DOCUMENT_SET: "Drawing attached by hand",
|
||
A.DOC_ADD: "Document added",
|
||
A.DOC_REMOVE: "Document removed",
|
||
A.SET_VCLOSED: "Job closed in VISUAL",
|
||
A.SET_DATABOOK_AT: "Data book date set",
|
||
A.REMOVE: "Packet removed",
|
||
}
|
||
|
||
AUDIT_ACTIONS: dict[policy.Action, str] = {A.REMOVE: "packet.removed", A.MOVE_UNIT: "packet.moved"}
|
||
|
||
|
||
# ---------------------------------------------------------------- request bodies
|
||
|
||
|
||
class SignBody(BaseModel):
|
||
factor: Literal["pin", "password"]
|
||
secret: str = Field(max_length=1024)
|
||
|
||
|
||
class Expect(BaseModel):
|
||
status: str = Field(max_length=20)
|
||
dept: str = Field(max_length=10)
|
||
|
||
|
||
# ---------------------------------------------------------------- the Write object
|
||
|
||
|
||
@dataclass
|
||
class Write:
|
||
conn: Any # the request connection, inside one transaction
|
||
principal: deps.Principal # the session principal
|
||
policy_principal: policy.Principal
|
||
packet: dict[str, Any] # the packets row, locked FOR UPDATE
|
||
state: policy.PacketState
|
||
decision: policy.Decision
|
||
signature: Signature | None
|
||
version: int # the new version after the bump (set on exit)
|
||
action: policy.Action
|
||
extra: Mapping[str, Any]
|
||
it_reason: str | None # the cleaned IT reason, kept only when the admin bypass was used
|
||
request: Request
|
||
label: str | None = None
|
||
note: str | None = None
|
||
fields: list[str] = field(default_factory=list)
|
||
detail: dict[str, Any] = field(default_factory=dict)
|
||
transitioned: bool = False
|
||
transition_id: int | None = None
|
||
noop: bool = False
|
||
from_status: str = ""
|
||
from_dept: str = ""
|
||
children: Any = None # packets.Children loaded under the lock (full=False)
|
||
more_logs: list[tuple[str, str | None]] = field(default_factory=list)
|
||
|
||
@property
|
||
def id(self) -> int:
|
||
return int(self.packet["id"])
|
||
|
||
@property
|
||
def user_id(self) -> Any:
|
||
return self.principal.user_id
|
||
|
||
@property
|
||
def rule(self) -> policy.Rule:
|
||
return policy.RULES[self.action]
|
||
|
||
def log(self, action_label: str, note: str | None = None) -> None:
|
||
"""Override the packet_log label (and note) for this write."""
|
||
self.label = action_label
|
||
if note is not None:
|
||
self.note = note
|
||
|
||
def log_also(self, action_label: str, note: str | None = None) -> None:
|
||
"""One more packet_log line for this write, written after the main one (same user, no signature)."""
|
||
self.more_logs.append((action_label, note))
|
||
|
||
def changed(self, *names: str) -> None:
|
||
"""Record the fields this write changed (they go into the audit detail)."""
|
||
for n in names:
|
||
if n not in self.fields:
|
||
self.fields.append(n)
|
||
|
||
def skip(self) -> None:
|
||
"""Nothing changed: no version bump, no log, audit or event."""
|
||
self.noop = True
|
||
|
||
def check(self, action: policy.Action, extra: Mapping[str, Any] | None = None) -> policy.Decision:
|
||
"""Check one more action on the same locked packet (for a write that touches several rules)."""
|
||
d = policy.check(self.policy_principal, self.state, action, extra=extra or self.extra, it_reason=self.it_reason)
|
||
refuse(d)
|
||
return d
|
||
|
||
|
||
# ---------------------------------------------------------------- helpers for callers
|
||
|
||
|
||
def refuse(decision: policy.Decision) -> None:
|
||
"""Raise the API error for a failed policy decision."""
|
||
if decision.ok:
|
||
return
|
||
status = 400 if decision.code in ASK_CODES else 403
|
||
raise ApiError(status, decision.code, decision.why)
|
||
|
||
|
||
def current_of(row: Mapping[str, Any]) -> dict[str, Any]:
|
||
return {"status": str(row["status"]), "dept": str(row["dept_code"]), "version": int(row["version"])}
|
||
|
||
|
||
def parse_if_match(request: Request) -> int | None:
|
||
"""The If-Match header as a plain integer (quotes and a W/ prefix are tolerated), or None when absent."""
|
||
raw = request.headers.get("if-match")
|
||
if raw is None:
|
||
return None
|
||
text = raw.strip().removeprefix("W/").strip().strip('"')
|
||
try:
|
||
return int(text)
|
||
except ValueError:
|
||
raise ApiError(400, "bad_if_match", "If-Match must be a version number.") from None
|
||
|
||
|
||
def require_if_match(request: Request) -> int:
|
||
v = parse_if_match(request)
|
||
if v is None:
|
||
raise ApiError(428, "if_match_required", "Send If-Match with the version you started from.")
|
||
return v
|
||
|
||
|
||
def check_row_version(row: Mapping[str, Any] | None, if_match: int | None, *, current: Any = None) -> None:
|
||
"""409 row_conflict with the current row when its row_version differs from If-Match.
|
||
|
||
`current` is what goes into the error (defaults to the row itself, JSON-shaped by the caller if needed).
|
||
A missing If-Match is 428 if_match_required.
|
||
"""
|
||
if row is None:
|
||
raise ApiError(404, "not_found", "No such line.")
|
||
if if_match is None:
|
||
raise ApiError(428, "if_match_required", "Send If-Match with the version you started from.")
|
||
if int(row["row_version"]) != int(if_match):
|
||
raise ApiError(
|
||
409, "row_conflict", MSG_ROW, extra={"current": jsonable(current if current is not None else row)}
|
||
)
|
||
|
||
|
||
def next_counter(conn: Any, packet_id: int, kind: str, n: int = 1) -> int:
|
||
"""Take `n` consecutive numbers from a packet counter (weld, heat, page, co); returns the first one.
|
||
|
||
Call it inside packet_write: the packet row is locked FOR UPDATE, so concurrent writers serialise on it.
|
||
Outside a pipeline the UPDATE itself takes the row lock for the rest of the transaction.
|
||
"""
|
||
col = COUNTERS.get(kind)
|
||
if col is None:
|
||
raise ValueError(f"unknown counter {kind!r}")
|
||
if n < 1:
|
||
raise ValueError("n must be at least 1")
|
||
row = conn.execute(
|
||
f"UPDATE packets SET {col} = {col} + %s WHERE id = %s RETURNING {col} - %s", # noqa: S608 (col from COUNTERS)
|
||
(n, packet_id, n),
|
||
).fetchone()
|
||
if row is None:
|
||
raise ApiError(404, "not_found", "No such packet.")
|
||
return int(row[0])
|
||
|
||
|
||
def _norm(value: Any) -> Any:
|
||
"""Comparable form of a value: uuid and dates as text, numbers as numbers, '' as None."""
|
||
if value is None or value == "":
|
||
return None
|
||
if isinstance(value, bool | int | float | str):
|
||
return value
|
||
return str(value)
|
||
|
||
|
||
def apply_field_cas(
|
||
current: Mapping[str, Any], set_: Mapping[str, Any], base: Mapping[str, Any] | None
|
||
) -> dict[str, Any]:
|
||
"""Field-level compare-and-set. For every key in set_ that base also has, base must equal current.
|
||
|
||
Conflicts raise 409 field_conflict with `current: {key: value}` for the conflicting keys. Keys without a base
|
||
entry are written without a check (the old merge3: mine wins). Returns the keys whose value actually changes.
|
||
"""
|
||
base = base or {}
|
||
conflicts = {k: current.get(k) for k in set_ if k in base and _norm(base[k]) != _norm(current.get(k))}
|
||
if conflicts:
|
||
raise ApiError(409, "field_conflict", MSG_FIELD, extra={"current": jsonable(conflicts)})
|
||
return {k: v for k, v in set_.items() if _norm(v) != _norm(current.get(k))}
|
||
|
||
|
||
def jsonable(value: Any) -> Any:
|
||
from fastapi.encoders import jsonable_encoder
|
||
|
||
return jsonable_encoder(value)
|
||
|
||
|
||
# ---------------------------------------------------------------- the pipeline
|
||
|
||
|
||
@contextmanager
|
||
def packet_write(
|
||
d: deps.Db,
|
||
p: deps.Principal,
|
||
packet_id: int,
|
||
action: policy.Action,
|
||
*,
|
||
request: Request,
|
||
extra: Mapping[str, Any] | None = None,
|
||
it_reason: str | None = None,
|
||
sign: SignBody | None = None,
|
||
expect: Expect | None = None,
|
||
sign_content: Any = None,
|
||
if_match: int | None = None,
|
||
also: Sequence[policy.Action] = (),
|
||
require_sign: bool | None = None,
|
||
policy_principal: policy.Principal | None = None,
|
||
) -> Iterator[Write]:
|
||
"""One packet write. See the module docstring for the order of steps.
|
||
|
||
`also` lists more actions the same write needs (each is checked; the first action is the one logged).
|
||
`require_sign` overrides the rule's signature: False skips it (removing a hand-attached drawing), True forces it.
|
||
"""
|
||
conn = d.conn
|
||
extra = dict(extra or {})
|
||
pp = policy_principal or packets.policy_principal_for(conn, p)
|
||
failure: ApiError | None = None
|
||
with conn.transaction():
|
||
row = packets.load_row(conn, packet_id, lock=True)
|
||
if row is None:
|
||
raise ApiError(404, "not_found", "No such packet.")
|
||
ch = packets.load_children(conn, row, full=False)
|
||
state = packets.state_from(row, ch)
|
||
if expect is not None and (expect.status != row["status"] or expect.dept != row["dept_code"]):
|
||
raise ApiError(409, "stale_step", MSG_STALE, extra={"current": current_of(row)})
|
||
extra.setdefault("holder_name", packets.holder_text(state, ch))
|
||
rule = policy.RULES[action]
|
||
if not state.removed and state.status == "filed" and not rule.filed_ok:
|
||
# Say "filed" rather than "wrong status" or "give an IT reason": nothing but a reopen changes it.
|
||
raise ApiError(403, "filed", MSG_FILED)
|
||
cleaned_it = reason_ok(it_reason)
|
||
decision = policy.check(pp, state, action, extra=extra, it_reason=it_reason)
|
||
refuse(decision)
|
||
bypass = decision.admin_bypass
|
||
for other in also:
|
||
dd = policy.check(pp, state, other, extra=extra, it_reason=it_reason)
|
||
refuse(dd)
|
||
bypass = bypass or dd.admin_bypass
|
||
if if_match is not None and int(if_match) != int(row["version"]):
|
||
raise ApiError(409, "version_conflict", MSG_VERSION, extra={"current": current_of(row)})
|
||
w = Write(
|
||
conn=conn,
|
||
principal=p,
|
||
policy_principal=pp,
|
||
packet=row,
|
||
state=state,
|
||
decision=decision,
|
||
signature=None,
|
||
version=int(row["version"]),
|
||
action=action,
|
||
extra=extra,
|
||
it_reason=cleaned_it if bypass else None,
|
||
request=request,
|
||
from_status=str(row["status"]),
|
||
from_dept=str(row["dept_code"]),
|
||
children=ch,
|
||
)
|
||
meaning = decision.signature
|
||
needs = bool(meaning) if require_sign is None else require_sign
|
||
if needs:
|
||
if sign is None:
|
||
raise ApiError(
|
||
400,
|
||
"signature_required",
|
||
"This step needs your signature.",
|
||
extra={"meaning": meaning or LABELS.get(action, str(action))},
|
||
)
|
||
try:
|
||
w.signature = signatures.sign(
|
||
conn,
|
||
deps.directory_of(request),
|
||
p.actor,
|
||
factor=sign.factor,
|
||
secret=sign.secret,
|
||
action=f"packet.{action}",
|
||
meaning=meaning,
|
||
packet_id=packet_id,
|
||
subject_type="packet",
|
||
subject_id=packet_id,
|
||
content=sign_content
|
||
if sign_content is not None
|
||
else {"action": str(action), "packet_id": packet_id, "version": int(row["version"])},
|
||
ip=p.ip,
|
||
settings=deps.settings_of(request),
|
||
)
|
||
except ApiError as e:
|
||
failure = e # commit the step-up failure records, then raise below
|
||
if failure is None:
|
||
yield w
|
||
_finish(w)
|
||
if failure is not None:
|
||
raise failure
|
||
|
||
|
||
def _finish(w: Write) -> None:
|
||
if w.noop:
|
||
return
|
||
if w.rule.transition and not w.transitioned:
|
||
apply_transition(w)
|
||
conn = w.conn
|
||
w.version = int(
|
||
conn.execute("UPDATE packets SET version = version + 1 WHERE id = %s RETURNING version", (w.id,)).fetchone()[0]
|
||
)
|
||
after = conn.execute("SELECT status::text, dept_code FROM packets WHERE id = %s", (w.id,)).fetchone()
|
||
status, dept = str(after[0]), str(after[1])
|
||
label = w.label or LABELS.get(w.action, str(w.action).replace("_", " ").capitalize())
|
||
note = clean_opt(w.note, LIMITS["note"]) if w.note else None
|
||
sig_id = w.signature.id if w.signature else None
|
||
conn.execute(
|
||
"INSERT INTO packet_log (packet_id, by, by_name, role, action, note, it_reason, signature_id, transition_id)"
|
||
" VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)",
|
||
(
|
||
w.id,
|
||
w.user_id,
|
||
w.principal.user["display_name"],
|
||
w.principal.role_snapshot,
|
||
label,
|
||
note,
|
||
w.it_reason,
|
||
sig_id,
|
||
w.transition_id,
|
||
),
|
||
)
|
||
for extra_label, extra_note in w.more_logs:
|
||
conn.execute(
|
||
"INSERT INTO packet_log (packet_id, by, by_name, role, action, note, it_reason)"
|
||
" VALUES (%s, %s, %s, %s, %s, %s, %s)",
|
||
(
|
||
w.id,
|
||
w.user_id,
|
||
w.principal.user["display_name"],
|
||
w.principal.role_snapshot,
|
||
extra_label,
|
||
clean_opt(extra_note, LIMITS["note"]) if extra_note else None,
|
||
w.it_reason,
|
||
),
|
||
)
|
||
detail: dict[str, Any] = {"from": w.from_status, "to": status, "dept": dept}
|
||
if w.from_dept != dept:
|
||
detail["from_dept"] = w.from_dept
|
||
if w.fields:
|
||
detail["fields"] = w.fields
|
||
if note:
|
||
detail["note"] = note
|
||
if sig_id:
|
||
detail["signature_id"] = sig_id
|
||
detail.update(w.detail)
|
||
audit.append(
|
||
conn,
|
||
action=AUDIT_ACTIONS.get(w.action, f"packet.{w.action}"),
|
||
user_id=w.user_id,
|
||
session_id=w.principal.session_id,
|
||
role_snapshot=w.principal.role_snapshot,
|
||
subject_type="packet",
|
||
subject_id=w.id,
|
||
packet_id=w.id,
|
||
detail=detail,
|
||
it_reason=w.it_reason,
|
||
ip=w.principal.ip,
|
||
)
|
||
events.publish(conn, {"event": "changed", "packet_id": w.id, "version": w.version, "status": status, "dept": dept})
|
||
|
||
|
||
# ---------------------------------------------------------------- transitions and their side effects
|
||
|
||
|
||
CLOCK_STOP = (
|
||
"clock_elapsed_ms = clock_elapsed_ms + CASE WHEN clock_running_since IS NULL THEN 0"
|
||
" ELSE (extract(epoch FROM (now() - clock_running_since)) * 1000)::bigint END, clock_running_since = NULL"
|
||
)
|
||
|
||
|
||
def _reason(w: Write) -> str | None:
|
||
return reason_ok(w.extra.get("reason"))
|
||
|
||
|
||
def _note(w: Write) -> str | None:
|
||
return clean_opt(w.extra.get("note"), LIMITS["note"])
|
||
|
||
|
||
def _wh_incoming(w: Write) -> None:
|
||
w.conn.execute("UPDATE packet_wh SET closed_at = now() WHERE packet_id = %s AND closed_at IS NULL", (w.id,))
|
||
w.conn.execute(
|
||
"INSERT INTO packet_wh (packet_id, stage, by, note) VALUES (%s, 'incoming', %s, %s)",
|
||
(w.id, w.user_id, _note(w)),
|
||
)
|
||
|
||
|
||
def _wh_close(w: Write) -> None:
|
||
w.conn.execute("UPDATE packet_wh SET closed_at = now() WHERE packet_id = %s AND closed_at IS NULL", (w.id,))
|
||
|
||
|
||
def _open_stage(w: Write, dept: str) -> None:
|
||
w.conn.execute("INSERT INTO packet_stages (packet_id, dept_code) VALUES (%s, %s)", (w.id, dept))
|
||
|
||
|
||
def _close_stage(w: Write, qc_snapshot: Any = None) -> None:
|
||
w.conn.execute(
|
||
f"UPDATE packet_stages SET {CLOCK_STOP}, closed_at = now(), qc_snapshot = coalesce(%s, qc_snapshot)," # noqa: S608
|
||
" row_version = row_version + 1 WHERE packet_id = %s AND closed_at IS NULL",
|
||
(None if qc_snapshot is None else Jsonb(jsonable(qc_snapshot)), w.id),
|
||
)
|
||
|
||
|
||
def _stage_update(w: Write, assignments: str, params: Sequence[Any] = ()) -> None:
|
||
w.conn.execute(
|
||
f"UPDATE packet_stages SET {assignments}, row_version = row_version + 1" # noqa: S608 (fixed fragments)
|
||
" WHERE packet_id = %s AND closed_at IS NULL",
|
||
(*params, w.id),
|
||
)
|
||
|
||
|
||
def _open_inspection(w: Write) -> dict[str, Any] | None:
|
||
return packets.one(w.conn, "SELECT * FROM qc_inspections WHERE packet_id = %s AND closed_at IS NULL", (w.id,))
|
||
|
||
|
||
def _close_inspection(w: Write, insp: Mapping[str, Any] | None, dept: str) -> None:
|
||
"""Close the open inspection; when it had a result, keep it in qc_history."""
|
||
if insp is None:
|
||
return
|
||
w.conn.execute(
|
||
"UPDATE qc_inspections SET closed_at = now(), row_version = row_version + 1 WHERE id = %s", (insp["id"],)
|
||
)
|
||
if insp.get("result"):
|
||
w.conn.execute(
|
||
"INSERT INTO qc_history (packet_id, result, inspector, note, dept_code, snapshot)"
|
||
" VALUES (%s, %s, %s, %s, %s, %s)",
|
||
(w.id, insp["result"], insp.get("inspector"), insp.get("result_note"), dept, Jsonb(jsonable(dict(insp)))),
|
||
)
|
||
|
||
|
||
def _set_result(w: Write, insp: Mapping[str, Any] | None, result: str, note: str | None) -> dict[str, Any] | None:
|
||
if insp is None:
|
||
return None
|
||
return packets.one(
|
||
w.conn,
|
||
"UPDATE qc_inspections SET result = %s, result_at = now(), result_by = %s, result_note = %s,"
|
||
" signature_id = %s, row_version = row_version + 1 WHERE id = %s RETURNING *",
|
||
(result, w.user_id, note, w.signature.id if w.signature else None, insp["id"]),
|
||
)
|
||
|
||
|
||
def _set_packet(w: Write, assignments: str, params: Sequence[Any] = ()) -> None:
|
||
w.conn.execute(f"UPDATE packets SET {assignments} WHERE id = %s", (*params, w.id)) # noqa: S608 (fixed fragments)
|
||
|
||
|
||
def _settings(w: Write) -> Any:
|
||
return deps.settings_of(w.request)
|
||
|
||
|
||
def seal_key_id(key: bytes) -> str:
|
||
return hashlib.sha256(key).hexdigest()[:8]
|
||
|
||
|
||
def seal_hash(key: bytes, content: Any) -> bytes:
|
||
return hmac.new(key, signatures.canonical_json(content), hashlib.sha256).digest()
|
||
|
||
|
||
def _seal_key(w: Write) -> bytes:
|
||
try:
|
||
key: bytes = _settings(w).seal_key()
|
||
except SecretFileError as e:
|
||
log.error("seal key unavailable: %s", e)
|
||
raise ApiError(503, "server_misconfigured", "The server is missing its seal key.") from None
|
||
return key
|
||
|
||
|
||
def qty_text(value: Any) -> str:
|
||
"""A quantity without trailing zeros: 4, 2.5."""
|
||
if value is None:
|
||
return "0"
|
||
try:
|
||
f = float(value)
|
||
except (TypeError, ValueError):
|
||
return str(value)
|
||
return str(int(f)) if f.is_integer() else f"{f:g}"
|
||
|
||
|
||
def _release_text(w: Write) -> None:
|
||
"""The old release label and note.
|
||
|
||
Label "Released to supervisor", or "... with {n} short"; note "{heats} heats recorded", plus " · SHORT: ..."
|
||
when shorts are open.
|
||
"""
|
||
lines = packets.rows(
|
||
w.conn,
|
||
"SELECT b.item, b.heat, s.qty_open, s.reason FROM bom_lines b LEFT JOIN bom_shorts s"
|
||
" ON s.bom_line_id = b.id AND s.closed_at IS NULL WHERE b.packet_id = %s ORDER BY b.item",
|
||
(w.id,),
|
||
)
|
||
heats = sum(1 for b in lines if str(b["heat"] or "").strip())
|
||
shorts = [b for b in lines if b["qty_open"] is not None]
|
||
note = f"{heats} heats recorded"
|
||
if shorts:
|
||
note += " · SHORT: " + ", ".join(
|
||
f"item {b['item']} ×{qty_text(b['qty_open'])} ({b['reason'] or ''})" for b in shorts
|
||
)
|
||
w.log(f"{LABELS[A.WH_RELEASE]} with {len(shorts)} short", note)
|
||
else:
|
||
w.log(LABELS[A.WH_RELEASE], note)
|
||
|
||
|
||
def hours_text(ms: Any) -> str:
|
||
"""Stage clock hours with one decimal: 1.5 h."""
|
||
return f"{int(ms or 0) / 3600000:.1f} h"
|
||
|
||
|
||
def _station_name(w: Write, station_id: Any) -> str | None:
|
||
if station_id is None:
|
||
return None
|
||
ch = w.children
|
||
if ch is not None and ch.station and ch.station.get("id") == station_id:
|
||
return str(ch.station["name"])
|
||
r = w.conn.execute("SELECT name FROM stations WHERE id = %s", (station_id,)).fetchone()
|
||
return str(r[0]) if r else None
|
||
|
||
|
||
def _dept_text(w: Write, code: str) -> str:
|
||
labels = getattr(w.children, "dept_labels", None) or packets.dept_labels(w.conn)
|
||
return str(labels.get(code, code))
|
||
|
||
|
||
def _shop_texts(w: Write, a: policy.Action, to_dept: str, stamp: str | None = None) -> None:
|
||
"""The packet_log label and note of a shop step (the old click handlers' texts)."""
|
||
ex = w.extra
|
||
here = _station_name(w, w.packet["station_id"]) or "the station"
|
||
note = _note(w)
|
||
if a is A.ASSIGN:
|
||
station = _station_name(w, int(ex["station_id"])) or "a station"
|
||
r = w.conn.execute("SELECT display_name FROM users WHERE id = %s", (str(ex["welder_id"]),)).fetchone()
|
||
who = str(r[0]) if r else ""
|
||
w.log(f"Sent to {station}", f"{who} [{stamp}]" if stamp else who)
|
||
elif a is A.UNASSIGN:
|
||
w.log(f"Taken off {here}", note)
|
||
elif a is A.PULL_BACK:
|
||
w.log(f"Pulled back from {here}", note)
|
||
elif a is A.START:
|
||
w.log(LABELS[A.START], " · ".join(x for x in (here if w.packet["station_id"] else None, note) if x) or None)
|
||
elif a is A.SUBMIT:
|
||
r = w.conn.execute(
|
||
"SELECT clock_elapsed_ms FROM packet_stages WHERE packet_id = %s AND closed_at IS NULL", (w.id,)
|
||
).fetchone()
|
||
n = packets.dept_welds(w.packet, w.children) if w.children is not None else 0
|
||
text = f"{n} welds · {hours_text(r[0] if r else 0)}"
|
||
w.log(LABELS[A.SUBMIT], f"{text} · {note}" if note else text)
|
||
elif a is A.RETURN_TO_STATION:
|
||
w.log(f"Returned to {here}", _reason(w))
|
||
elif a is A.SEND_TO_QC:
|
||
loc = clean_opt(ex.get("location"), LIMITS["location"])
|
||
w.log(LABELS[A.SEND_TO_QC], " · ".join(x for x in (f"Spool at {loc}" if loc else None, note) if x) or None)
|
||
elif a is A.ROUTE_FROM_REVIEW:
|
||
text = f"Supervisor, Q.C. skipped · from {_dept_text(w, w.from_dept)}"
|
||
w.log(f"Routed to {_dept_text(w, to_dept)}", f"{text} · {note}" if note else text)
|
||
|
||
|
||
SHOP_TEXTS = frozenset(
|
||
{A.ASSIGN, A.UNASSIGN, A.PULL_BACK, A.START, A.SUBMIT, A.RETURN_TO_STATION, A.SEND_TO_QC, A.ROUTE_FROM_REVIEW}
|
||
)
|
||
|
||
|
||
def apply_transition(w: Write) -> None:
|
||
"""Set status, status_at and dept, write the packet_transitions row and run the action's side effects."""
|
||
if w.transitioned:
|
||
return
|
||
w.transitioned = True
|
||
a = w.action
|
||
rule = w.rule
|
||
to_status = rule.to_status
|
||
assert to_status is not None
|
||
ex = w.extra
|
||
reason = _reason(w)
|
||
from_dept = w.from_dept
|
||
to_dept = from_dept
|
||
if rule.dept_change != "no" and isinstance(ex.get("dept"), str) and ex.get("dept"):
|
||
to_dept = str(ex["dept"])
|
||
|
||
stamp: str | None = None
|
||
if a in SHOP_TEXTS and a is not A.ASSIGN and a is not A.SUBMIT:
|
||
_shop_texts(w, a, to_dept) # before the side effects clear the station
|
||
|
||
if a in (A.SEND_TO_WAREHOUSE, A.VIS_AUTO_RELEASE):
|
||
_set_packet(w, "wh_skipped = false, wh_sent_at = now(), return_note = NULL")
|
||
_wh_incoming(w)
|
||
elif a is A.RELEASE_TO_SHOP:
|
||
_set_packet(
|
||
w,
|
||
"wh_skipped = true, for_sup_id = %s, return_note = %s",
|
||
(ex.get("for_sup_id") or None, _note(w)),
|
||
)
|
||
_close_stage(w)
|
||
_open_stage(w, to_dept)
|
||
elif a is A.SEND_DRAFT_TO_QC:
|
||
_set_packet(w, "wh_skipped = true")
|
||
_close_inspection(w, _open_inspection(w), from_dept)
|
||
w.conn.execute(
|
||
"INSERT INTO qc_inspections (packet_id, sent_by, sent_note) VALUES (%s, %s, %s)",
|
||
(w.id, w.user_id, _note(w)),
|
||
)
|
||
elif a is A.WH_SEND_BACK:
|
||
_set_packet(w, "return_note = %s", (reason,))
|
||
_wh_close(w)
|
||
elif a is A.RETURN_TO_CLERICAL:
|
||
_set_packet(w, "return_note = %s", (reason,))
|
||
_close_stage(w)
|
||
elif a is A.WH_RELEASE:
|
||
_release_text(w)
|
||
_wh_close(w)
|
||
_close_stage(w)
|
||
_open_stage(w, to_dept)
|
||
elif a is A.SEND_BACK_TO_WAREHOUSE:
|
||
_set_packet(w, "return_note = %s, wh_skipped = false", (reason,))
|
||
_close_stage(w)
|
||
_wh_incoming(w)
|
||
elif a is A.ASSIGN:
|
||
station_id = int(ex["station_id"])
|
||
welder_id = str(ex["welder_id"])
|
||
stamp = clean_opt(ex.get("stamp"), LIMITS["stamp"])
|
||
if stamp is None:
|
||
r = w.conn.execute("SELECT welder_stamp FROM users WHERE id = %s", (welder_id,)).fetchone()
|
||
stamp = r[0] if r else None
|
||
_set_packet(w, "station_id = %s, welder_id = %s, welder_stamp = %s", (station_id, welder_id, stamp))
|
||
if not packets.one(w.conn, "SELECT id FROM packet_stages WHERE packet_id = %s AND closed_at IS NULL", (w.id,)):
|
||
_open_stage(w, from_dept)
|
||
_stage_update(w, "station_id = %s, welder_id = %s, welder_stamp = %s", (station_id, welder_id, stamp))
|
||
_shop_texts(w, a, to_dept, stamp)
|
||
elif a in (A.UNASSIGN, A.PULL_BACK):
|
||
_set_packet(w, "station_id = NULL, welder_id = NULL, welder_stamp = NULL")
|
||
_stage_update(w, f"{CLOCK_STOP}, station_id = NULL, welder_id = NULL, welder_stamp = NULL")
|
||
elif a is A.START:
|
||
# A clock that is already running keeps its start; only the server sets it.
|
||
_stage_update(
|
||
w,
|
||
"clock_running_since = coalesce(clock_running_since, now()),"
|
||
" clock_started_at = coalesce(clock_started_at, now())",
|
||
)
|
||
elif a is A.SUBMIT:
|
||
_set_packet(w, "return_note = NULL")
|
||
_stage_update(w, CLOCK_STOP)
|
||
_shop_texts(w, a, to_dept)
|
||
elif a is A.RETURN_TO_STATION:
|
||
_set_packet(w, "return_note = %s", (reason,))
|
||
elif a is A.SEND_TO_QC:
|
||
_close_inspection(w, _open_inspection(w), from_dept)
|
||
stage = packets.one(w.conn, "SELECT id FROM packet_stages WHERE packet_id = %s AND closed_at IS NULL", (w.id,))
|
||
w.conn.execute(
|
||
"INSERT INTO qc_inspections (packet_id, stage_id, sent_by, book, spool, location, sent_note)"
|
||
" VALUES (%s, %s, %s, %s, %s, %s, %s)",
|
||
(
|
||
w.id,
|
||
stage["id"] if stage else None,
|
||
w.user_id,
|
||
ex.get("book") is True,
|
||
ex.get("spool") is True,
|
||
clean_opt(ex.get("location"), LIMITS["location"]),
|
||
_note(w),
|
||
),
|
||
)
|
||
elif a in (A.ROUTE_FROM_REVIEW, A.QC_ACCEPT_AND_ROUTE):
|
||
insp = _open_inspection(w)
|
||
if a is A.QC_ACCEPT_AND_ROUTE:
|
||
insp = _set_result(w, insp, "accepted", _note(w))
|
||
_close_stage(w, qc_snapshot=insp)
|
||
_close_inspection(w, insp, from_dept)
|
||
_open_stage(w, to_dept)
|
||
_set_packet(w, "station_id = NULL, welder_id = NULL, welder_stamp = NULL, return_note = NULL, routed_to = NULL")
|
||
elif a is A.QC_REJECT:
|
||
_set_result(w, _open_inspection(w), "rejected", reason)
|
||
_set_packet(w, "return_note = %s", (reason,))
|
||
if not packets.one(w.conn, "SELECT id FROM packet_stages WHERE packet_id = %s AND closed_at IS NULL", (w.id,)):
|
||
_open_stage(w, from_dept) # a draft sent straight to Q.C. has no stage yet
|
||
elif a is A.QC_ACCEPT:
|
||
insp = _set_result(w, _open_inspection(w), "accepted", _note(w))
|
||
_close_inspection(w, insp, from_dept)
|
||
_close_stage(w, qc_snapshot=insp)
|
||
_set_packet(w, "routed_to = %s::route_kind", (str(ex["routed_to"]),))
|
||
|
||
_set_packet(w, "status = %s::packet_status, status_at = now(), dept_code = %s", (to_status, to_dept))
|
||
|
||
if a is A.FILE:
|
||
key = _seal_key(w)
|
||
row = packets.load_row(w.conn, w.id)
|
||
assert row is not None
|
||
content = packets.seal_content(w.conn, row)
|
||
w.conn.execute(
|
||
"INSERT INTO packet_seals (packet_id, hash, key_id, sealed_by, signature_id) VALUES (%s, %s, %s, %s, %s)",
|
||
(w.id, seal_hash(key, content), seal_key_id(key), w.user_id, w.signature.id if w.signature else None),
|
||
)
|
||
elif a is A.ADMIN_REOPEN:
|
||
w.conn.execute(
|
||
"UPDATE packet_seals SET broken_at = now(), broken_by = %s, broken_reason = %s"
|
||
" WHERE packet_id = %s AND broken_at IS NULL",
|
||
(w.user_id, reason, w.id),
|
||
)
|
||
|
||
tid = w.conn.execute(
|
||
"INSERT INTO packet_transitions (packet_id, by, action, from_status, to_status, from_dept, to_dept, reason,"
|
||
" signature_id, it_reason) VALUES (%s, %s, %s, %s::packet_status, %s::packet_status, %s, %s, %s, %s, %s)"
|
||
" RETURNING id",
|
||
(
|
||
w.id,
|
||
w.user_id,
|
||
str(a),
|
||
w.from_status,
|
||
to_status,
|
||
from_dept,
|
||
to_dept,
|
||
reason or _note(w),
|
||
w.signature.id if w.signature else None,
|
||
w.it_reason,
|
||
),
|
||
).fetchone()
|
||
w.transition_id = int(tid[0])
|
||
if w.note is None:
|
||
w.note = reason or _note(w)
|
||
|
||
|
||
def verify_seal(conn: Any, settings: Any, packet_id: int) -> dict[str, Any]:
|
||
"""The seal history of a packet and whether the current unbroken seal still matches the packet."""
|
||
seals = packets.rows(conn, "SELECT * FROM packet_seals WHERE packet_id = %s ORDER BY id DESC", (packet_id,))
|
||
people = packets.People(conn, [s["sealed_by"] for s in seals] + [s["broken_by"] for s in seals])
|
||
current = next((s for s in seals if s["broken_at"] is None), None)
|
||
valid: bool | None = None
|
||
if current is not None:
|
||
try:
|
||
key = settings.seal_key()
|
||
except SecretFileError:
|
||
key = None
|
||
if key is not None and seal_key_id(key) == current["key_id"]:
|
||
row = packets.load_row(conn, packet_id)
|
||
assert row is not None
|
||
valid = hmac.compare_digest(seal_hash(key, packets.seal_content(conn, row)), bytes(current["hash"]))
|
||
|
||
def shape(s: Mapping[str, Any]) -> dict[str, Any]:
|
||
return {
|
||
"id": s["id"],
|
||
"sealed_at": s["sealed_at"],
|
||
"sealed_by": people.ref(s["sealed_by"]),
|
||
"key_id": s["key_id"],
|
||
"hash": bytes(s["hash"]).hex(),
|
||
"signed": s["signature_id"] is not None,
|
||
"broken_at": s["broken_at"],
|
||
"broken_by": people.ref(s["broken_by"]),
|
||
"broken_reason": s["broken_reason"],
|
||
}
|
||
|
||
return {"seal": shape(current) if current else None, "valid": valid, "seals": [shape(s) for s in seals]}
|