fix(spoolman): harden slot-assignment CRUD, sync robustness, and full test coverage

- Add SpoolmanSlotAssignment model and DB migration for (printer, ams, tray) → spool_id mapping
- Slot-assignment CRUD endpoints: verify spool exists before DB commit (H2), re-raise
  non-404 Spoolman errors from GET (H3), return success on 404 after DELETE (H4/CR1)
- DB rollbacks added to all sync batch-persist except blocks (C1/C2/C3) and unlink_spool (H6)
- Slot-map load failures promoted from debug to warning level (H1, 3 sites)
- Sync: add SkippedSpool tracking for no-RFID/no-hint trays (CR3), fix asymmetry in
  sync_all_printers so not-found errors are also reported for non-BL RFID trays
- sync_ams_tray non-BL RFID path: wrap find_or_create_filament in try/except (H5)
- on_ams_change: add isinstance guards for ams_unit/tray_data (CR4); catch ValueError
  from init_spoolman_client so SSRF-blocked URLs log a warning and return cleanly
- delete_printer: explicitly delete SpoolmanSlotAssignment rows (SQLite FK cascade not
  enforced without PRAGMA foreign_keys; pattern matches existing maintenance cleanup)
- S4: move SpoolmanSlotAssignment import to module top-level in spoolman.py and
  spoolman_inventory.py; remove 3 duplicate in-function imports
- Remove dead variables current_tray_uuids/synced_spool_ids across sync routes (S2/CA1)
- Update stale docstrings: clear_location_for_removed_spools (CA3), ON CONFLICT comment
  for assigned_at (CA4), assign_spoolman_slot 404 note (CA5), get_all raw dict format (CA6)
- DB init: add spoolman_slot_assignment to model import list; fix active_print_spoolman
  and spool_usage_history DDL to use is_sqlite() branching (removes AUTOINCREMENT from
  PostgreSQL path)
- Frontend: slot-assignment API client methods, AssignSpoolModal integration,
  PrintersPage AMS slot UI, i18n keys for all 8 locales
- Tests T1-T9: link/unlink Spoolman error paths, slot GET stale-row cleanup, 503
  propagation, sync DB write, hint forwarding, no-RFID skipped entry, non-BL RFID
  error guard, hint uncached path, hint ignored when RFID present, CASCADE delete

Author: netscout2001

backend/app/api/routes/printers.py

@@ -299,6 +299,7 @@ async def delete_printer(
 
     from backend.app.models.archive import PrintArchive
     from backend.app.models.maintenance import MaintenanceHistory, PrinterMaintenance
+    from backend.app.models.spoolman_slot_assignment import SpoolmanSlotAssignment
 
     result = await db.execute(select(Printer).where(Printer.id == printer_id))
     printer = result.scalar_one_or_none()
@@ -316,6 +317,9 @@ async def delete_printer(
 
         await db.execute(update(PrintArchive).where(PrintArchive.printer_id == printer_id).values(printer_id=None))
 
+    # Delete slot assignments for this printer (SQLite doesn't enforce FK cascades)
+    await db.execute(sql_delete(SpoolmanSlotAssignment).where(SpoolmanSlotAssignment.printer_id == printer_id))
+
     # Delete maintenance history and items for this printer
     # (SQLite doesn't enforce FK cascades, so do it explicitly)
     maintenance_ids = (

backend/app/api/routes/spoolman.py

@@ -15,7 +15,7 @@
 from fastapi import APIRouter, Depends, HTTPException, Path, Query, Response
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field, field_validator, model_validator
-from sqlalchemy import select
+from sqlalchemy import delete, select, text
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from backend.app.api.routes._spoolman_helpers import (
@@ -27,7 +27,9 @@
 from backend.app.core.auth import RequirePermissionIfAuthEnabled
 from backend.app.core.database import get_db
 from backend.app.core.permissions import Permission
+from backend.app.models.printer import Printer
 from backend.app.models.settings import Settings
+from backend.app.models.spoolman_slot_assignment import SpoolmanSlotAssignment
 from backend.app.models.user import User
 from backend.app.services.spoolman import (
     SpoolmanClient,
@@ -234,6 +236,13 @@ class SpoolWeightUpdate(BaseModel):
     weight_grams: float = Field(..., ge=0.0, le=100_000.0)
 
 
+class SpoolSlotAssignmentRequest(BaseModel):
+    spoolman_spool_id: int = Field(..., gt=0)
+    printer_id: int = Field(..., gt=0)
+    ams_id: int = Field(..., ge=0)
+    tray_id: int = Field(..., ge=0)
+
+
 # ---------------------------------------------------------------------------
 # Endpoints
 # ---------------------------------------------------------------------------
@@ -529,3 +538,147 @@ async def sync_spool_weight(
     label_weight = _safe_int(upd_filament.get("weight"), 1000)
     weight_used = max(0.0, label_weight - remaining)
     return {"status": "ok", "weight_used": weight_used}
+
+
+@router.get("/slot-assignments/all")
+async def get_all_spoolman_slot_assignments(
+    printer_id: int | None = Query(None, gt=0),
+    db: AsyncSession = Depends(get_db),
+    _: User | None = RequirePermissionIfAuthEnabled(Permission.INVENTORY_READ),
+) -> list[dict]:
+    """Return all Spoolman slot assignments, optionally filtered by printer.
+
+    Each item is a raw assignment dict with keys ``printer_id``, ``ams_id``,
+    ``tray_id``, and ``spoolman_spool_id`` — not an ``InventorySpool`` object.
+    """
+    query = select(SpoolmanSlotAssignment)
+    if printer_id is not None:
+        query = query.where(SpoolmanSlotAssignment.printer_id == printer_id)
+    result = await db.execute(query)
+    slots = result.scalars().all()
+    return [
+        {
+            "printer_id": s.printer_id,
+            "ams_id": s.ams_id,
+            "tray_id": s.tray_id,
+            "spoolman_spool_id": s.spoolman_spool_id,
+        }
+        for s in slots
+    ]
+
+
+@router.post("/slot-assignments")
+async def assign_spoolman_slot(
+    body: SpoolSlotAssignmentRequest,
+    db: AsyncSession = Depends(get_db),
+    _: User | None = RequirePermissionIfAuthEnabled(Permission.INVENTORY_UPDATE),
+) -> dict:
+    """Assign a Spoolman spool to a printer AMS slot (stored in local DB only).
+
+    Raises 404 if the printer does not exist or the spool is not found in Spoolman.
+    Spoolman's own ``spool.location`` field is NOT touched — it is user-managed.
+    """
+
+    client = await _get_client(db)
+    result = await db.execute(select(Printer).where(Printer.id == body.printer_id))
+    printer = result.scalar_one_or_none()
+    if not printer:
+        raise HTTPException(status_code=404, detail="Printer not found")
+
+    # Verify the Spoolman spool exists before committing to local DB.
+    # This prevents ghost rows pointing at non-existent spool IDs.
+    async with _translate_spoolman_errors():
+        spool = await client.get_spool(body.spoolman_spool_id)
+
+    # Spool confirmed in Spoolman — upsert into local slot-assignment table
+    # assigned_at is intentionally not refreshed on re-assign (original timestamp preserved)
+    await db.execute(
+        text(
+            "INSERT INTO spoolman_slot_assignments"
+            " (printer_id, ams_id, tray_id, spoolman_spool_id)"
+            " VALUES (:printer_id, :ams_id, :tray_id, :spool_id)"
+            " ON CONFLICT(printer_id, ams_id, tray_id)"
+            " DO UPDATE SET spoolman_spool_id = excluded.spoolman_spool_id"
+        ),
+        {
+            "printer_id": body.printer_id,
+            "ams_id": body.ams_id,
+            "tray_id": body.tray_id,
+            "spool_id": body.spoolman_spool_id,
+        },
+    )
+    await db.commit()
+
+    return _map_spoolman_spool(spool)
+
+
+@router.delete("/slot-assignments/{spoolman_spool_id}")
+async def unassign_spoolman_slot(
+    spoolman_spool_id: int = Path(..., gt=0),
+    db: AsyncSession = Depends(get_db),
+    _: User | None = RequirePermissionIfAuthEnabled(Permission.INVENTORY_UPDATE),
+) -> dict:
+    """Remove the local slot assignment for a Spoolman spool.
+
+    Spoolman's own ``spool.location`` field is NOT touched — it is user-managed.
+    """
+    client = await _get_client(db)
+
+    # Delete from local slot-assignment table (all slots for this spool ID)
+    await db.execute(
+        delete(SpoolmanSlotAssignment).where(SpoolmanSlotAssignment.spoolman_spool_id == spoolman_spool_id)
+    )
+    await db.commit()
+
+    # Fetch the spool from Spoolman to return in InventorySpool format.
+    # If the spool no longer exists in Spoolman, the local unassignment still succeeded.
+    try:
+        async with _translate_spoolman_errors():
+            spool = await client.get_spool(spoolman_spool_id)
+        return _map_spoolman_spool(spool)
+    except HTTPException as exc:
+        if exc.status_code != 404:
+            raise
+        # Spool no longer exists in Spoolman; unassignment still succeeded.
+        return {"id": spoolman_spool_id}
+
+
+@router.get("/slot-assignments")
+async def get_spoolman_slot_assignment(
+    printer_id: int = Query(..., gt=0),
+    ams_id: int = Query(..., ge=0),
+    tray_id: int = Query(..., ge=0),
+    db: AsyncSession = Depends(get_db),
+    _: User | None = RequirePermissionIfAuthEnabled(Permission.INVENTORY_READ),
+) -> dict | None:
+    """Return the Spoolman spool assigned to a specific printer slot, or null if unassigned."""
+    client = await _get_client(db)
+    result = await db.execute(select(Printer).where(Printer.id == printer_id))
+    printer = result.scalar_one_or_none()
+    if not printer:
+        raise HTTPException(status_code=404, detail="Printer not found")
+
+    slot_result = await db.execute(
+        select(SpoolmanSlotAssignment).where(
+            SpoolmanSlotAssignment.printer_id == printer_id,
+            SpoolmanSlotAssignment.ams_id == ams_id,
+            SpoolmanSlotAssignment.tray_id == tray_id,
+        )
+    )
+    slot = slot_result.scalar_one_or_none()
+    if not slot:
+        return None
+
+    try:
+        async with _translate_spoolman_errors():
+            spool = await client.get_spool(slot.spoolman_spool_id)
+        return _map_spoolman_spool(spool)
+    except HTTPException as exc:
+        if exc.status_code != 404:
+            raise
+        # Spool deleted in Spoolman — clean up stale assignment
+        await db.execute(
+            delete(SpoolmanSlotAssignment).where(SpoolmanSlotAssignment.id == slot.id)
+        )
+        await db.commit()
+        return None

backend/app/api/routes/spoolman_inventory.py

@@ -189,6 +189,7 @@ async def init_db():
         spool_k_profile,
         spool_usage_history,
         spoolbuddy_device,
+        spoolman_slot_assignment,
         user,
         user_email_pref,
         user_otp_code,
@@ -1062,25 +1063,36 @@ async def run_migrations(conn):
         pass  # Already applied
 
     # Create active_print_spoolman table for Spoolman per-filament tracking
-    try:
-        async with conn.begin_nested():
-            await conn.execute(
-                text("""
-                CREATE TABLE IF NOT EXISTS active_print_spoolman (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    printer_id INTEGER NOT NULL REFERENCES printers(id) ON DELETE CASCADE,
-                    archive_id INTEGER NOT NULL REFERENCES print_archives(id) ON DELETE CASCADE,
-                    filament_usage TEXT NOT NULL,
-                    ams_trays TEXT NOT NULL,
-                    slot_to_tray TEXT,
-                    layer_usage TEXT,
-                    filament_properties TEXT,
-                    UNIQUE(printer_id, archive_id)
-                )
-            """)
-            )
-    except (OperationalError, ProgrammingError):
-        pass  # Already applied
+    await _safe_execute(
+        conn,
+        """
+        CREATE TABLE IF NOT EXISTS active_print_spoolman (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            printer_id INTEGER NOT NULL REFERENCES printers(id) ON DELETE CASCADE,
+            archive_id INTEGER NOT NULL REFERENCES print_archives(id) ON DELETE CASCADE,
+            filament_usage TEXT NOT NULL,
+            ams_trays TEXT NOT NULL,
+            slot_to_tray TEXT,
+            layer_usage TEXT,
+            filament_properties TEXT,
+            UNIQUE(printer_id, archive_id)
+        )
+        """
+        if is_sqlite()
+        else """
+        CREATE TABLE IF NOT EXISTS active_print_spoolman (
+            id SERIAL PRIMARY KEY,
+            printer_id INTEGER NOT NULL REFERENCES printers(id) ON DELETE CASCADE,
+            archive_id INTEGER NOT NULL REFERENCES print_archives(id) ON DELETE CASCADE,
+            filament_usage TEXT NOT NULL,
+            ams_trays TEXT NOT NULL,
+            slot_to_tray TEXT,
+            layer_usage TEXT,
+            filament_properties TEXT,
+            UNIQUE(printer_id, archive_id)
+        )
+        """,
+    )
 
     # Migration: Add preset_source column to slot_preset_mappings for local preset support
     try:
@@ -1109,24 +1121,34 @@ async def run_migrations(conn):
     await _safe_execute(conn, "ALTER TABLE spool ADD COLUMN core_weight_catalog_id INTEGER")
 
     # Migration: Create spool_usage_history table for filament consumption tracking
-    try:
-        async with conn.begin_nested():
-            await conn.execute(
-                text("""
-                CREATE TABLE IF NOT EXISTS spool_usage_history (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    spool_id INTEGER NOT NULL REFERENCES spool(id) ON DELETE CASCADE,
-                    printer_id INTEGER REFERENCES printers(id) ON DELETE SET NULL,
-                    print_name VARCHAR(500),
-                    weight_used REAL NOT NULL DEFAULT 0,
-                    percent_used INTEGER NOT NULL DEFAULT 0,
-                    status VARCHAR(20) NOT NULL DEFAULT 'completed',
-                    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-                )
-            """)
-            )
-    except (OperationalError, ProgrammingError):
-        pass  # Already applied
+    await _safe_execute(
+        conn,
+        """
+        CREATE TABLE IF NOT EXISTS spool_usage_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            spool_id INTEGER NOT NULL REFERENCES spool(id) ON DELETE CASCADE,
+            printer_id INTEGER REFERENCES printers(id) ON DELETE SET NULL,
+            print_name VARCHAR(500),
+            weight_used REAL NOT NULL DEFAULT 0,
+            percent_used INTEGER NOT NULL DEFAULT 0,
+            status VARCHAR(20) NOT NULL DEFAULT 'completed',
+            created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+        if is_sqlite()
+        else """
+        CREATE TABLE IF NOT EXISTS spool_usage_history (
+            id SERIAL PRIMARY KEY,
+            spool_id INTEGER NOT NULL REFERENCES spool(id) ON DELETE CASCADE,
+            printer_id INTEGER REFERENCES printers(id) ON DELETE SET NULL,
+            print_name VARCHAR(500),
+            weight_used REAL NOT NULL DEFAULT 0,
+            percent_used INTEGER NOT NULL DEFAULT 0,
+            status VARCHAR(20) NOT NULL DEFAULT 'completed',
+            created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+        """,
+    )
 
     # Migration: Add open_in_new_tab column to external_links
     await _safe_execute(conn, "ALTER TABLE external_links ADD COLUMN open_in_new_tab BOOLEAN DEFAULT 0")
@@ -1162,8 +1184,9 @@ async def run_migrations(conn):
     await _safe_execute(conn, "ALTER TABLE spool ADD COLUMN storage_location VARCHAR(255)")
     # Migration: Widen tag_uid column from VARCHAR(16) to VARCHAR(32) to accommodate 7-byte NFC
     # UIDs (14 hex chars) in addition to 8-byte Bambu Lab UIDs (16 hex chars).
-    # SQLite ignores VARCHAR sizes; this is a no-op there but needed for PostgreSQL.
-    await _safe_execute(conn, "ALTER TABLE spool ALTER COLUMN tag_uid TYPE VARCHAR(32)")
+    # ALTER COLUMN ... TYPE is PostgreSQL-only syntax; SQLite ignores VARCHAR sizes so no-op there.
+    if not is_sqlite():
+        await _safe_execute(conn, "ALTER TABLE spool ALTER COLUMN tag_uid TYPE VARCHAR(32)")
     # Migration: Add cost field to spool_usage_history table
     await _safe_execute(conn, "ALTER TABLE spool_usage_history ADD COLUMN cost REAL")
     # Migration: Add archive_id field to spool_usage_history table
@@ -1677,6 +1700,36 @@ async def run_migrations(conn):
             )
         )
 
+    # Migration: Create spoolman_slot_assignments table for local AMS-slot→Spoolman-spool mapping.
+    # Replaces the pattern of writing spool.location in Spoolman (which polluted the
+    # user-editable storage_location field in the UI).
+    await _safe_execute(
+        conn,
+        """
+        CREATE TABLE IF NOT EXISTS spoolman_slot_assignments (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            printer_id INTEGER NOT NULL REFERENCES printers(id) ON DELETE CASCADE,
+            ams_id INTEGER NOT NULL,
+            tray_id INTEGER NOT NULL,
+            spoolman_spool_id INTEGER NOT NULL,
+            assigned_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE(printer_id, ams_id, tray_id)
+        )
+        """
+        if is_sqlite()
+        else """
+        CREATE TABLE IF NOT EXISTS spoolman_slot_assignments (
+            id SERIAL PRIMARY KEY,
+            printer_id INTEGER NOT NULL REFERENCES printers(id) ON DELETE CASCADE,
+            ams_id INTEGER NOT NULL,
+            tray_id INTEGER NOT NULL,
+            spoolman_spool_id INTEGER NOT NULL,
+            assigned_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE(printer_id, ams_id, tray_id)
+        )
+        """,
+    )
+
     # Seed default settings keys that must exist on fresh install
     default_settings = [
         ("advanced_auth_enabled", "false"),