# Shop Floor Plant View — Implementation Plan > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. **Goal:** Replace the per-step-grouped Shop Floor kanban with a 9-column department-grouped kanban (one card per job, fixed sequence, 13 distinct card states) per the spec at `docs/superpowers/specs/2026-05-23-shopfloor-plant-view-design.md`. **Architecture:** New `area_kind` taxonomy on `fp.work.centre` drives column placement. Server-computed `card_state` on `fp.job` classifies each job into 1 of 13 mutually-exclusive visual states with explicit precedence. New endpoint `/fp/landing/plant_kanban` returns columns + denormalized cards in one payload. New OWL component tree (`fp_plant_kanban`) replaces `shopfloor_landing` behind a feature flag. Dev system, sample data only — no production migration concerns. **Tech Stack:** Odoo 19 (Python 3.11, OWL 2), PostgreSQL, native odoo on entech (LXC 111 on pve-worker5). Tests use `odoo.tests.common.TransactionCase`. SCSS compiled by Odoo's bundle pipeline with dark-mode branch via `$o-webclient-color-scheme`. --- ## Critical patterns to follow These are project rules already documented in `K:/Github/Odoo-Modules/fusion_plating/CLAUDE.md` — re-stating here so the implementer doesn't have to context-switch: - **OWL template scope**: only `Math` is exposed as a JS global. NEVER write `String(x)`, `Number(x)`, `parseInt(x)`, `JSON.stringify(x)`, etc. inside `t-on-click`, `t-att-*`, or `t-out` — they throw `Uncaught TypeError: v2 is not a function` at click time and the handler silently dies. Use string literals in arrays, do all coercion in JS-side handler methods, or use operators (`+x` works as a number cast because `+` is an operator). - **OWL `t-out` HTML escape**: plain strings get escaped. To render HTML from RPC, wrap with `markup()` from `@odoo/owl` in the JS before assigning to state. - **SCSS @import forbidden**: every SCSS file (including `_tokens.scss` partials) must be registered as a separate entry in the manifest's `web.assets_backend`. Tokens first. Concatenation is sequential. - **Dark mode**: NOT via class selector or media query. Use `$o-webclient-color-scheme == dark` `@if` branch at SCSS compile time. Same SCSS file compiles into both light and dark bundles automatically. - **Existing field naming**: new custom fields on standard Odoo models use `x_fc_*` prefix. New custom models use `fp.*`. New non-prefixed fields on FP models (e.g. `card_state`, `area_kind`, `last_activity_at`) are fine because the model is custom. - **End every git commit message with**: `Co-Authored-By: Claude Opus 4.7 (1M context) ` - **Existing single-station pairing UX stays for MVP**. The new `paired_work_centre_ids` M2M holds exactly one record on day 1 (the existing selected station). Multi-station picker is Phase 2. --- ## File structure map ### Backend — modify | File | What changes | |---|---| | `fusion_plating/models/fp_work_centre.py` | Add `area_kind` Selection field | | `fusion_plating/__manifest__.py` | Bump version to `19.0.21.0.0` | | `fusion_plating_jobs/models/fp_job.py` | Add `card_state`, `mini_timeline_json` computes + 6 `_fp_*` precedence helpers | | `fusion_plating_jobs/models/fp_job_step.py` | Add `area_kind` related-with-fallback + `last_activity_at` + `_fp_is_idle` helper | | `fusion_plating_jobs/__manifest__.py` | Bump version to `19.0.10.24.0` | | `fusion_plating_shopfloor/models/res_users.py` | Add `paired_work_centre_ids` M2M | | `fusion_plating_shopfloor/models/res_config_settings.py` *(may not exist; if not, create)* | Add `x_fc_shopfloor_layout` Selection | | `fusion_plating_shopfloor/__manifest__.py` | Bump version to `19.0.31.0.0`, register new assets in correct order | | `fusion_plating_shopfloor/views/res_config_settings_views.xml` | Surface the layout setting | ### Backend — create | File | Responsibility | |---|---| | `fusion_plating/migrations/19.0.21.0.0/post-migrate.py` | Backfill `area_kind` on existing `fp.work.centre` rows | | `fusion_plating_shopfloor/controllers/plant_kanban.py` | `/fp/landing/plant_kanban` endpoint | | `fusion_plating_jobs/tests/test_card_state.py` | Tests for all 13 states + precedence | | `fusion_plating_jobs/tests/test_area_kind_routing.py` | Tests for step-kind → column mapping | | `fusion_plating_jobs/tests/test_mini_timeline.py` | Tests for 9-element timeline output | | `fusion_plating_shopfloor/tests/test_plant_kanban_endpoint.py` | Endpoint integration tests | ### Frontend — create All under `fusion_plating_shopfloor/static/src/`: | File | Responsibility | |---|---| | `scss/_plant_tokens.scss` | Design tokens (colors per card state, sizes) — loads first | | `scss/plant_kanban.scss` | Board layout, sticky header, polling spinner | | `scss/components/_plant_card.scss` | All 13 card-state styles | | `scss/components/_mini_timeline.scss` | 9-step horizontal bar | | `scss/components/_column_header.scss` | "📍 You're here" badge + count chip | | `scss/components/_kpi_tile.scss` | Clickable KPI button | | `scss/components/_filter_chip.scss` | Toggleable chip | | `js/plant_kanban.js` | Top-level OWL action `fp_plant_kanban` | | `js/components/plant_card.js` | Variant C card | | `js/components/mini_timeline.js` | 9-step bar | | `js/components/column_header.js` | Header + you're-here badge | | `js/components/kpi_tile.js` | KPI button + click-to-filter | | `js/components/filter_chip.js` | Filter chip toggle | | `xml/plant_kanban.xml` | Top-level template | | `xml/components/plant_card.xml` | Card template | | `xml/components/mini_timeline.xml` | Timeline template | | `xml/components/column_header.xml` | Header template | | `xml/components/kpi_tile.xml` | KPI template | | `xml/components/filter_chip.xml` | Chip template | --- ## Phase 1 — Data model foundation ### Task 1: Add `area_kind` to `fp.work.centre` **Files:** - Modify: `fusion_plating/models/fp_work_centre.py` - Modify: `fusion_plating/__manifest__.py` (bump version) - Create: `fusion_plating/migrations/19.0.21.0.0/post-migrate.py` - Test: existing tests still pass — no new test required (data-layer-only change) - [ ] **Step 1: Read the existing file and confirm structure** ```bash grep -n "kind = fields\.Selection" K:/Github/Odoo-Modules/fusion_plating/fusion_plating/models/fp_work_centre.py ``` Locate the existing `kind` field. The new field goes right after it. - [ ] **Step 2: Add the `area_kind` Selection** In `fusion_plating/models/fp_work_centre.py`, immediately after the existing `kind` field, add: ```python area_kind = fields.Selection( [ ('receiving', 'Receiving'), ('masking', 'Masking'), ('blasting', 'Blasting'), ('racking', 'Racking'), ('plating', 'Plating'), ('baking', 'Baking'), ('de_racking', 'De-Racking'), ('inspection', 'Final inspection'), ('shipping', 'Shipping'), ], string='Floor Column', help='Which Shop Floor column this work centre belongs to. ' 'Drives the plant-view kanban grouping. Set this to one of ' 'the nine departments; the plant view will route any job ' 'whose active step uses this work centre into that column.', index=True, ) ``` - [ ] **Step 3: Bump module version** In `fusion_plating/__manifest__.py`, change `'version': '19.0.20.9.0'` → `'version': '19.0.21.0.0'`. - [ ] **Step 4: Create the migration directory + post-migrate script** ```bash mkdir -p K:/Github/Odoo-Modules/fusion_plating/fusion_plating/migrations/19.0.21.0.0 ``` Create `fusion_plating/migrations/19.0.21.0.0/post-migrate.py`: ```python # -*- coding: utf-8 -*- # Backfill fp.work.centre.area_kind from the existing kind taxonomy. # Runs on -u fusion_plating after the new column is added. import logging _logger = logging.getLogger(__name__) def migrate(cr, version): """Map existing kind values onto the new 9-area taxonomy. Unmapped centres get 'plating' as a safe catch-all (wet shop default) plus a warning so the admin knows to review them. The kanban can still render those jobs; they'll just appear in the Plating column until the admin sets the correct area_kind. """ cr.execute(""" UPDATE fp_work_centre SET area_kind = CASE kind WHEN 'wet_line' THEN 'plating' WHEN 'bake' THEN 'baking' WHEN 'mask' THEN 'masking' WHEN 'rack' THEN 'racking' WHEN 'inspect' THEN 'inspection' ELSE 'plating' END WHERE area_kind IS NULL """) cr.execute(""" SELECT id, name, kind FROM fp_work_centre WHERE area_kind = 'plating' AND kind NOT IN ('wet_line', NULL) """) rows = cr.fetchall() if rows: _logger.warning( "%d fp.work.centre rows defaulted to area_kind='plating'; " "review and adjust if needed: %s", len(rows), ', '.join('%s (id=%s, kind=%s)' % (r[1], r[0], r[2]) for r in rows[:10]), ) ``` - [ ] **Step 5: Apply locally + verify** ```bash ssh pve-worker5 "pct exec 111 -- bash -c 'systemctl stop odoo && su - odoo -s /bin/bash -c \"/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating --stop-after-init\" 2>&1 | tail -20 && systemctl start odoo'" ``` Then: ```bash ssh pve-worker5 "pct exec 111 -- su - postgres -c \"psql -d admin -c \\\"SELECT kind, area_kind, count(*) FROM fp_work_centre GROUP BY kind, area_kind ORDER BY kind;\\\"\"" ``` Expected: every row has `area_kind` set. No NULLs. - [ ] **Step 6: Commit** ```bash cd K:/Github/Odoo-Modules/fusion_plating && git add fusion_plating/models/fp_work_centre.py fusion_plating/__manifest__.py fusion_plating/migrations/19.0.21.0.0/post-migrate.py && git commit -m "feat(plating): add fp.work.centre.area_kind for plant-view kanban Adds a 9-value Selection field routing each work centre to one of the Shop Floor columns (Receiving / Masking / Blasting / Racking / Plating / Baking / De-Racking / Final inspection / Shipping). Migration 19.0.21.0.0 backfills existing rows from their kind value: wet_line→plating, bake→baking, mask→masking, rack→racking, inspect→inspection. Unmapped centres default to 'plating' and are logged for admin review. Part of the 2026-05-23 Shop Floor plant-view redesign (spec at docs/superpowers/specs/2026-05-23-shopfloor-plant-view-design.md). Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 2: Add `area_kind` to `fp.job.step` with step-kind fallback **Files:** - Modify: `fusion_plating_jobs/models/fp_job_step.py` - Test: `fusion_plating_jobs/tests/test_area_kind_routing.py` (create) The field is **stored computed** (not pure related) because we need the fallback to recipe-step `default_kind` when the work_centre is missing or its `area_kind` is unset. - [ ] **Step 1: Write the failing test first** Create `fusion_plating_jobs/tests/test_area_kind_routing.py`: ```python # -*- coding: utf-8 -*- from odoo.tests.common import TransactionCase class TestAreaKindRouting(TransactionCase): """Verifies that fp.job.step.area_kind routes correctly for every recipe step kind in the project's step library, including when work_centre is absent and the fallback dispatch kicks in.""" @classmethod def setUpClass(cls): super().setUpClass() cls.Job = cls.env['fp.job'] cls.Step = cls.env['fp.job.step'] cls.Node = cls.env['fusion.plating.process.node'] def _make_step_with_kind(self, default_kind, work_centre=None): """Build a minimal fp.job + fp.job.step pair with a recipe node of the given default_kind. work_centre optional — if absent, the fallback dispatch should still route the step to the right area.""" partner = self.env['res.partner'].create({'name': 'Test Co'}) job = self.Job.create({ 'name': 'TEST-WO', 'partner_id': partner.id, 'qty': 1, }) node = self.Node.create({ 'name': 'Test step', 'node_type': 'step', 'default_kind': default_kind, }) step = self.Step.create({ 'job_id': job.id, 'name': node.name, 'recipe_node_id': node.id, 'sequence': 10, 'work_centre_id': work_centre.id if work_centre else False, }) return step def test_racking_step_routes_to_racking_column(self): step = self._make_step_with_kind('racking') self.assertEqual(step.area_kind, 'racking') def test_masking_step_routes_to_masking(self): step = self._make_step_with_kind('masking') self.assertEqual(step.area_kind, 'masking') def test_blasting_step_routes_to_blasting(self): step = self._make_step_with_kind('blasting') self.assertEqual(step.area_kind, 'blasting') def test_de_rack_routes_to_de_racking(self): step = self._make_step_with_kind('de_rack') self.assertEqual(step.area_kind, 'de_racking') def test_de_mask_also_routes_to_de_racking(self): # Spec D4: de-masking folds into de-racking. step = self._make_step_with_kind('de_mask') self.assertEqual(step.area_kind, 'de_racking') def test_wet_steps_all_route_to_plating(self): for kind in ('soak_clean', 'electroclean', 'acid_dip', 'etch', 'desmut', 'zincate', 'rinse', 'water_break_test', 'e_nickel_plate', 'chrome', 'anodize', 'black_oxide', 'drying'): step = self._make_step_with_kind(kind) self.assertEqual( step.area_kind, 'plating', "expected '%s' → plating, got %r" % (kind, step.area_kind), ) def test_bake_routes_to_baking(self): step = self._make_step_with_kind('bake') self.assertEqual(step.area_kind, 'baking') def test_inspection_steps_route_to_inspection(self): for kind in ('final_inspection', 'post_plate_inspection', 'thickness_qc', 'fair'): step = self._make_step_with_kind(kind) self.assertEqual(step.area_kind, 'inspection') def test_contract_review_routes_to_receiving(self): # Spec D5: contract review cards live in Receiving with a chip. step = self._make_step_with_kind('contract_review') self.assertEqual(step.area_kind, 'receiving') def test_incoming_inspection_routes_to_receiving(self): step = self._make_step_with_kind('incoming_inspection') self.assertEqual(step.area_kind, 'receiving') def test_shipping_routes_to_shipping(self): step = self._make_step_with_kind('shipping') self.assertEqual(step.area_kind, 'shipping') def test_unknown_kind_defaults_to_plating(self): step = self._make_step_with_kind('some_made_up_kind') self.assertEqual(step.area_kind, 'plating') def test_work_centre_area_kind_wins_over_step_kind(self): # When the work_centre carries an explicit area_kind, it # overrides the recipe-step fallback (more specific data). wc = self.env['fp.work.centre'].create({ 'name': 'Test Inspect Bench', 'code': 'INSP-TEST', 'kind': 'inspect', 'area_kind': 'inspection', }) # default_kind says racking, but work_centre says inspection step = self._make_step_with_kind('racking', work_centre=wc) self.assertEqual(step.area_kind, 'inspection') ``` - [ ] **Step 2: Run the failing test** ```bash ssh pve-worker5 "pct exec 111 -- bash -c 'cat > /mnt/extra-addons/custom/fusion_plating_jobs/tests/test_area_kind_routing.py' < K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/tests/test_area_kind_routing.py && ssh pve-worker5 \"pct exec 111 -- su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin --test-enable --stop-after-init --log-level=test -i fusion_plating_jobs --test-tags /fusion_plating_jobs:TestAreaKindRouting' 2>&1 | tail -30\"" ``` Expected: tests fail with `AttributeError: 'fp.job.step' object has no attribute 'area_kind'`. - [ ] **Step 3: Add the kind-mapping module-level constant + the field** In `fusion_plating_jobs/models/fp_job_step.py`, near the top imports area, add: ```python # Mapping from fp.process.node.default_kind → fp.work.centre.area_kind. # Used as fallback when the step's work_centre is unset OR its work_centre # has no area_kind. Authoritative source per spec §4.2. _STEP_KIND_TO_AREA = { # Receiving 'receiving': 'receiving', 'incoming_inspection': 'receiving', 'contract_review': 'receiving', 'gating': 'receiving', 'ready_for_processing':'receiving', # Masking 'masking': 'masking', # Blasting 'blasting': 'blasting', 'bead_blast': 'blasting', 'media_blast': 'blasting', # Racking 'racking': 'racking', # Plating (everything wet) 'soak_clean': 'plating', 'electroclean': 'plating', 'acid_dip': 'plating', 'etch': 'plating', 'desmut': 'plating', 'zincate': 'plating', 'rinse': 'plating', 'water_break_test': 'plating', 'activation': 'plating', 'e_nickel_plate': 'plating', 'chrome': 'plating', 'anodize': 'plating', 'black_oxide': 'plating', 'drying': 'plating', # Baking 'bake': 'baking', 'oven_bake': 'baking', 'post_bake_relief': 'baking', # De-Racking (folds in de-masking per spec D4) 'de_rack': 'de_racking', 'de_mask': 'de_racking', 'unrack': 'de_racking', # Inspection 'inspection': 'inspection', 'final_inspection': 'inspection', 'post_plate_inspection':'inspection', 'thickness_qc': 'inspection', 'fair': 'inspection', 'dimensional_check': 'inspection', # Shipping 'shipping': 'shipping', 'pack_ship': 'shipping', } ``` Then inside the `FpJobStep` class, after the existing `recipe_node_id` field, add: ```python area_kind = fields.Selection( selection=[ ('receiving', 'Receiving'), ('masking', 'Masking'), ('blasting', 'Blasting'), ('racking', 'Racking'), ('plating', 'Plating'), ('baking', 'Baking'), ('de_racking', 'De-Racking'), ('inspection', 'Final inspection'), ('shipping', 'Shipping'), ], string='Floor Column', compute='_compute_area_kind', store=True, index=True, help='Which Shop Floor column this step belongs to. Resolved ' 'as: work_centre.area_kind if set; else fallback to recipe ' 'step kind via _STEP_KIND_TO_AREA; else "plating" as a safe ' 'catch-all.', ) ``` And the compute method: ```python @api.depends('work_centre_id.area_kind', 'recipe_node_id.default_kind') def _compute_area_kind(self): for step in self: # 1. Explicit work-centre area_kind wins if step.work_centre_id and step.work_centre_id.area_kind: step.area_kind = step.work_centre_id.area_kind continue # 2. Fallback to step-kind mapping kind = step.recipe_node_id.default_kind if step.recipe_node_id else False if kind and kind in _STEP_KIND_TO_AREA: step.area_kind = _STEP_KIND_TO_AREA[kind] continue # 3. Safe catch-all step.area_kind = 'plating' ``` - [ ] **Step 4: Run the tests — should now pass** ```bash ssh pve-worker5 "pct exec 111 -- bash -c 'cat > /mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job_step.py' < K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/models/fp_job_step.py && pct exec 111 -- su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin --test-enable --stop-after-init --log-level=test -u fusion_plating_jobs --test-tags /fusion_plating_jobs:TestAreaKindRouting' 2>&1 | tail -40" ``` Expected: all 13 tests pass. - [ ] **Step 5: Add the test file to `fusion_plating_jobs/tests/__init__.py`** if it has an `__init__.py` that imports tests. Check first: ```bash grep -n "test_" K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/tests/__init__.py 2>/dev/null ``` If the file has explicit imports of test modules, add `from . import test_area_kind_routing`. If it uses a glob, no change needed. - [ ] **Step 6: Bump `fusion_plating_jobs` manifest to `19.0.10.24.0`** - [ ] **Step 7: Commit** ```bash cd K:/Github/Odoo-Modules/fusion_plating && git add fusion_plating_jobs/models/fp_job_step.py fusion_plating_jobs/__manifest__.py fusion_plating_jobs/tests/test_area_kind_routing.py fusion_plating_jobs/tests/__init__.py && git commit -m "feat(jobs): add fp.job.step.area_kind for plant-view kanban routing Stored computed field that routes each step to one of the 9 Shop Floor columns. Resolution order: 1. step.work_centre_id.area_kind (most specific) 2. _STEP_KIND_TO_AREA[recipe_node.default_kind] (fallback table) 3. 'plating' (safe catch-all for unmapped kinds) The fallback table covers all 30+ step kinds in the project's step library, including the spec D4 rule (de_mask routes to de_racking) and D5 rule (contract_review routes to receiving). Tested with 13 dispatch scenarios. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 3: Add `last_activity_at` to `fp.job.step` Used by the idle-warning state computation (S16). Needs to update on every state transition / move / chatter post. **Files:** - Modify: `fusion_plating_jobs/models/fp_job_step.py` - [ ] **Step 1: Add the field** After the `area_kind` field, add: ```python last_activity_at = fields.Datetime( string='Last Activity', index=True, help='Updated on any state transition, move-out, or chatter post. ' 'Drives the idle-warning card state (S16 — step in_progress ' 'with no activity for 8+ hours).', ) ``` - [ ] **Step 2: Hook the write override** Find the existing `write()` method on `FpJobStep` (around line 265 per the earlier grep). Add a stamp to `last_activity_at` whenever `state` changes: ```python def write(self, vals): # Existing logic preserved... if 'state' in vals: vals.setdefault('last_activity_at', fields.Datetime.now()) return super().write(vals) ``` If the existing `write` is more complex, splice the timestamp update in just before the `super().write()` call. - [ ] **Step 3: Hook move creation** In `fusion_plating/models/fp_job_step_move.py`, add a small `create` override (or add to existing) that stamps `last_activity_at` on the from_step and to_step: ```python @api.model_create_multi def create(self, vals_list): moves = super().create(vals_list) Step = self.env['fp.job.step'] now = fields.Datetime.now() step_ids = set() for m in moves: if m.from_step_id: step_ids.add(m.from_step_id.id) if m.to_step_id: step_ids.add(m.to_step_id.id) if step_ids: Step.browse(list(step_ids)).sudo().write({'last_activity_at': now}) return moves ``` - [ ] **Step 4: Hook chatter — message_post override** In `fp.job.step`, override `message_post` to bump the timestamp: ```python def message_post(self, **kwargs): res = super().message_post(**kwargs) self.sudo().write({'last_activity_at': fields.Datetime.now()}) return res ``` - [ ] **Step 5: Add `_fp_is_idle` helper** ```python def _fp_is_idle(self, threshold_hours=8): """True when state=in_progress and last_activity_at is older than the threshold. Drives the S16 idle-warning card state.""" self.ensure_one() if self.state != 'in_progress': return False if not self.last_activity_at: return False delta = fields.Datetime.now() - self.last_activity_at return delta.total_seconds() > threshold_hours * 3600 ``` - [ ] **Step 6: Backfill existing rows** Add to the `19.0.21.0.0/post-migrate.py` (we're already touching this version): ```python def migrate(cr, version): # ... existing area_kind backfill ... # Backfill last_activity_at from write_date for steps that don't have one yet cr.execute(""" UPDATE fp_job_step SET last_activity_at = write_date WHERE last_activity_at IS NULL """) ``` Wait — `last_activity_at` is on `fp_job_step` which is in `fusion_plating_jobs`, but the migration lives in `fusion_plating`. Move this backfill to `fusion_plating_jobs/migrations/19.0.10.24.0/post-migrate.py` instead. ```bash mkdir -p K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/migrations/19.0.10.24.0 ``` Create `fusion_plating_jobs/migrations/19.0.10.24.0/post-migrate.py`: ```python # -*- coding: utf-8 -*- import logging _logger = logging.getLogger(__name__) def migrate(cr, version): """Backfill fp.job.step.last_activity_at from write_date so existing in-progress steps don't immediately trigger the idle-warning gate on first compute.""" cr.execute(""" UPDATE fp_job_step SET last_activity_at = write_date WHERE last_activity_at IS NULL """) _logger.info("Backfilled last_activity_at on existing fp.job.step rows") ``` - [ ] **Step 7: Manual smoke test on entech** ```bash ssh pve-worker5 "pct exec 111 -- bash -c 'systemctl stop odoo && su - odoo -s /bin/bash -c \"/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --stop-after-init\" 2>&1 | tail -10 && systemctl start odoo'" ``` ```bash ssh pve-worker5 "pct exec 111 -- su - postgres -c \"psql -d admin -c \\\"SELECT count(*), count(last_activity_at) FROM fp_job_step;\\\"\"" ``` Expected: both counts equal — every row has `last_activity_at` populated. - [ ] **Step 8: Commit** ```bash git add fusion_plating_jobs/models/fp_job_step.py fusion_plating/models/fp_job_step_move.py fusion_plating_jobs/migrations/19.0.10.24.0/post-migrate.py && git commit -m "feat(jobs): add fp.job.step.last_activity_at for idle detection Tracks the last meaningful activity on a step (state transition, move-out, chatter post). Drives the S16 idle-warning card state (in_progress with no activity for 8+ hours). Backfilled from write_date on existing rows so jobs that were in-progress before this deploy don't immediately trip the gate. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 4: Add `paired_work_centre_ids` to `res.users` **Files:** - Modify: `fusion_plating_shopfloor/models/res_users.py` - [ ] **Step 1: Read the existing res_users.py** ```bash cat K:/Github/Odoo-Modules/fusion_plating/fusion_plating_shopfloor/models/res_users.py ``` Confirm the inherit pattern and existing fields. The new field goes alongside the existing `x_fc_tablet_pin_*` fields. - [ ] **Step 2: Add the M2M** ```python paired_work_centre_ids = fields.Many2many( 'fp.work.centre', 'res_users_fp_work_centre_paired_rel', 'user_id', 'work_centre_id', string='Paired Work Centres', help='Stations the operator is currently paired to via the tablet. ' 'MVP holds exactly one record on day 1 (the dropdown-selected ' 'station). Phase 2 multi-station picker can populate multiple. ' 'Drives the "is this card mine" check on the plant-view kanban.', ) ``` - [ ] **Step 3: Wire to the existing tablet pairing flow** Find the existing pairing code. Look for where `currentStationId` (in JS) is sent to the server. It's likely in `fp_shopfloor_tech_store.js` calling an endpoint. Trace it to the controller that handles unlock/pair: ```bash grep -rn "paired_station\|currentStationId\|fp_shopfloor_tech_store" K:/Github/Odoo-Modules/fusion_plating/fusion_plating_shopfloor/controllers/ K:/Github/Odoo-Modules/fusion_plating/fusion_plating_shopfloor/models/ 2>/dev/null ``` In the controller that handles `set_tech` / unlock, after the existing pairing write add: ```python # Mirror the single selected station into paired_work_centre_ids # (M2M) so the plant-view kanban can resolve "mine" cards. Forward- # compatible: a future multi-station picker writes the same M2M with # multiple records. station = request.env['fusion.plating.shopfloor.station'].browse(station_id) work_centre = station.work_centre_id if station else False user = request.env['res.users'].browse(user_id) if work_centre: user.sudo().paired_work_centre_ids = [(6, 0, [work_centre.id])] else: user.sudo().paired_work_centre_ids = [(5, 0, 0)] # clear ``` (Adjust the path from station → work_centre based on the actual schema. If `fp.shopfloor.station` has a different relation to `fp.work.centre`, use that.) - [ ] **Step 4: Smoke test** Restart odoo, pair to a station via the tablet, then check: ```bash ssh pve-worker5 "pct exec 111 -- su - postgres -c \"psql -d admin -c \\\"SELECT u.login, array_agg(wc.name) FROM res_users u LEFT JOIN res_users_fp_work_centre_paired_rel rel ON rel.user_id = u.id LEFT JOIN fp_work_centre wc ON wc.id = rel.work_centre_id WHERE u.login NOT LIKE '%@%' OR u.login LIKE '%enplating%' GROUP BY u.login;\\\"\"" ``` Expected: paired users have their station in the array. - [ ] **Step 5: Commit** ```bash git add fusion_plating_shopfloor/models/res_users.py fusion_plating_shopfloor/controllers/ && git commit -m "feat(shopfloor): add res.users.paired_work_centre_ids M2M M2M from res.users to fp.work.centre, populated on tablet pairing. MVP holds exactly one row (mirrors the single-station dropdown); forward-compatible for the Phase 2 multi-station picker. Drives the 'is this card mine' check on the plant-view kanban — without it the new view can't compute which cards belong to the paired operator. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 5: Add feature flag `x_fc_shopfloor_layout` **Files:** - Modify or create: `fusion_plating_shopfloor/models/res_config_settings.py` - Modify: `fusion_plating_shopfloor/views/res_config_settings_views.xml` - [ ] **Step 1: Check if the file exists** ```bash ls K:/Github/Odoo-Modules/fusion_plating/fusion_plating_shopfloor/models/res_config_settings.py 2>/dev/null ``` If not present, create it. If present, add the field. - [ ] **Step 2: Add the Selection field on `res.config.settings`** ```python # -*- coding: utf-8 -*- from odoo import fields, models class ResConfigSettings(models.TransientModel): _inherit = 'res.config.settings' x_fc_shopfloor_layout = fields.Selection( [ ('legacy', 'Legacy (per-step kanban)'), ('v2', 'Plant View (one card per job, 9 columns)'), ], string='Shop Floor Layout', default='legacy', config_parameter='fusion_plating_shopfloor.layout', help='Switches the Shop Floor client action between the legacy ' 'per-step kanban and the v2 plant view. Stays on legacy ' 'during the parallel rollout; flip to v2 once validated.', ) ``` `config_parameter` makes Odoo persist the value to `ir.config_parameter` (key `fusion_plating_shopfloor.layout`) so the resolver can read it without a `res.config.settings` recordset. - [ ] **Step 3: Surface in Settings UI** In `fusion_plating_shopfloor/views/res_config_settings_views.xml`, inside the existing Fusion Plating settings block, add: ```xml ``` If the XML file doesn't exist yet, create it following the project pattern in other `res_config_settings_views.xml` files. - [ ] **Step 4: Register the file in the manifest** In `fusion_plating_shopfloor/__manifest__.py`, add the views file to `'data':` if not already present. - [ ] **Step 5: Verify the setting saves** Restart odoo, open Settings → Fusion Plating, toggle the setting, save. Then: ```bash ssh pve-worker5 "pct exec 111 -- su - postgres -c \"psql -d admin -c \\\"SELECT key, value FROM ir_config_parameter WHERE key LIKE '%shopfloor%';\\\"\"" ``` Expected: `fusion_plating_shopfloor.layout` row with the selected value. - [ ] **Step 6: Commit** ```bash git add fusion_plating_shopfloor/models/res_config_settings.py fusion_plating_shopfloor/views/res_config_settings_views.xml fusion_plating_shopfloor/__manifest__.py && git commit -m "feat(shopfloor): add x_fc_shopfloor_layout feature flag Selection on res.config.settings (legacy / v2), backed by ir.config_parameter so the landing-action resolver can read it cheaply on every action open. Defaults to 'legacy' during parallel rollout. The new plant-view client action ships in subsequent commits; only the resolver needs to flip when we're ready to switch defaults. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ## Phase 2 — Card state computation ### Task 6: Add the 6 precedence helpers to `fp.job` **Files:** - Modify: `fusion_plating_jobs/models/fp_job.py` Each helper is a tiny pure function returning a bool. They're called by the `card_state` compute in the next task. Putting them first means the test in Task 7 can mock them cleanly. - [ ] **Step 1: Add helper methods on `fp.job`** ```python # === Card-state precedence helpers (spec §6.2 + §9.4) ================= # Each method returns a bool; the card_state compute calls them in # precedence order and the first truthy one wins. Add new states by # (a) adding a helper here, (b) adding the rule to _compute_card_state. def _fp_inbound_not_received(self): """True when the job is confirmed but the inbound fp.receiving record is still draft (parts haven't arrived). Card state = 'no_parts'.""" self.ensure_one() if self.state != 'confirmed': return False so = self.sale_order_id if not so or 'x_fc_receiving_ids' not in so._fields: return False return any(r.state == 'draft' for r in so.x_fc_receiving_ids) def _fp_has_open_hold(self): """True when an open fusion.plating.quality.hold exists for this job. Card state = 'on_hold'.""" self.ensure_one() if 'fusion.plating.quality.hold' not in self.env: return False Hold = self.env['fusion.plating.quality.hold'] return bool(Hold.search_count([ ('job_id', '=', self.id), ('state', '=', 'open'), ])) def _fp_has_pending_qc(self): """True when a quality check is in draft or in_progress on this job. Card state = 'awaiting_qc'.""" self.ensure_one() if 'fusion.plating.quality.check' not in self.env: return False QC = self.env['fusion.plating.quality.check'] return bool(QC.search_count([ ('job_id', '=', self.id), ('state', 'in', ('draft', 'in_progress')), ])) def _fp_bake_window_due_soon(self, threshold_hours=1): """True when a bake window is open AND its required-by deadline is within `threshold_hours`. Card state = 'bake_due'.""" self.ensure_one() if 'fusion.plating.bake.window' not in self.env: return False Window = self.env['fusion.plating.bake.window'] cutoff = fields.Datetime.now() + datetime.timedelta(hours=threshold_hours) # bake.window doesn't have a direct fp.job link in all installs; # find via the job's part_ref or sale_order_id depending on the # bake.window schema. Adjust the domain to match your install. domain = [ ('state', '=', 'awaiting_bake'), ('bake_required_by', '<=', cutoff), ] if 'job_id' in Window._fields: domain.append(('job_id', '=', self.id)) elif self.sale_order_id and 'sale_order_id' in Window._fields: domain.append(('sale_order_id', '=', self.sale_order_id.id)) return bool(Window.search_count(domain)) def _fp_is_mine(self, user=None): """True when the active step's work centre is in the operator's paired stations. Drives ready_mine / running_mine state.""" self.ensure_one() user = user or self.env.user if not self.active_step_id or not self.active_step_id.work_centre_id: return False paired = user.paired_work_centre_ids.ids if 'paired_work_centre_ids' in user._fields else [] return self.active_step_id.work_centre_id.id in paired ``` Add `import datetime` at the top of the file if not already present. Add a corresponding helper on `fp.job.step`: ```python def _fp_has_unfinished_predecessors(self): """True when an earlier-sequence step on the same job is not yet terminal (done/skipped/cancelled). Drives predecessor_locked.""" self.ensure_one() return bool(self.job_id.step_ids.filtered( lambda s: s.sequence < self.sequence and s.state not in ('done', 'skipped', 'cancelled') )) ``` - [ ] **Step 2: Smoke check — restart odoo, no errors on load** ```bash ssh pve-worker5 "pct exec 111 -- bash -c 'systemctl stop odoo && su - odoo -s /bin/bash -c \"/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --stop-after-init\" 2>&1 | grep -E \"(ERROR|loaded)\" | tail -10 && systemctl start odoo'" ``` - [ ] **Step 3: Commit** ```bash git add fusion_plating_jobs/models/fp_job.py && git commit -m "feat(jobs): add precedence helpers for plant-view card_state Six small _fp_* helpers on fp.job (plus one on fp.job.step) that each test one of the precedence conditions for the 13-state classifier in the next commit. Helpers are intentionally tiny and pure so they're cheap to call in the card_state compute and easy to mock in tests. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 7: Add `card_state` compute on `fp.job` (TDD) **Files:** - Modify: `fusion_plating_jobs/models/fp_job.py` - Test: `fusion_plating_jobs/tests/test_card_state.py` (create) - [ ] **Step 1: Write the failing tests** Create `fusion_plating_jobs/tests/test_card_state.py`: ```python # -*- coding: utf-8 -*- from unittest.mock import patch from odoo.tests.common import TransactionCase class TestCardState(TransactionCase): """One test per card state + one test per precedence pair.""" @classmethod def setUpClass(cls): super().setUpClass() cls.Job = cls.env['fp.job'] cls.Step = cls.env['fp.job.step'] cls.Node = cls.env['fusion.plating.process.node'] cls.partner = cls.env['res.partner'].create({'name': 'Test'}) def _make_job_with_active_step(self, step_kind='racking', step_state='ready'): job = self.Job.create({ 'name': 'WO-TEST', 'partner_id': self.partner.id, 'qty': 1, 'state': 'in_progress', }) node = self.Node.create({ 'name': 'Step', 'node_type': 'step', 'default_kind': step_kind, }) self.Step.create({ 'job_id': job.id, 'name': node.name, 'recipe_node_id': node.id, 'sequence': 10, 'state': step_state, }) # Force active_step recompute job.invalidate_recordset(['active_step_id']) return job # ---- one test per state ------------------------------------------- def test_ready_state(self): job = self._make_job_with_active_step(step_state='ready') self.assertEqual(job.card_state, 'ready') def test_running_state(self): job = self._make_job_with_active_step(step_state='in_progress') self.assertEqual(job.card_state, 'running') def test_done_state(self): # All steps done, job state=done, on shipping job = self._make_job_with_active_step('shipping', 'in_progress') job.state = 'done' self.assertEqual(job.card_state, 'done') def test_contract_review_state(self): job = self._make_job_with_active_step('contract_review', 'in_progress') self.assertEqual(job.card_state, 'contract_review') def test_on_hold_wins_over_running(self): job = self._make_job_with_active_step(step_state='in_progress') with patch.object(type(job), '_fp_has_open_hold', return_value=True): self.assertEqual(job.card_state, 'on_hold') def test_awaiting_signoff(self): job = self._make_job_with_active_step(step_state='in_progress') step = job.active_step_id step.requires_signoff = True # if related field, set on recipe_node if not step.requires_signoff: step.recipe_node_id.requires_signoff = True step.invalidate_recordset(['requires_signoff']) step.state = 'done' step.signoff_user_id = False job.invalidate_recordset(['card_state']) self.assertEqual(job.card_state, 'awaiting_signoff') def test_awaiting_qc(self): job = self._make_job_with_active_step(step_state='in_progress') with patch.object(type(job), '_fp_has_pending_qc', return_value=True): self.assertEqual(job.card_state, 'awaiting_qc') def test_bake_due(self): job = self._make_job_with_active_step(step_state='in_progress') with patch.object(type(job), '_fp_bake_window_due_soon', return_value=True): self.assertEqual(job.card_state, 'bake_due') def test_predecessor_locked(self): job = self._make_job_with_active_step(step_state='ready') step = job.active_step_id # Insert an unfinished predecessor prior = self.Step.create({ 'job_id': job.id, 'name': 'Earlier', 'sequence': 5, 'state': 'pending', }) with patch.object(type(step), '_fp_should_block_predecessors', return_value=True): job.invalidate_recordset(['card_state']) self.assertEqual(job.card_state, 'predecessor_locked') def test_idle_warning(self): job = self._make_job_with_active_step(step_state='in_progress') step = job.active_step_id with patch.object(type(step), '_fp_is_idle', return_value=True): job.invalidate_recordset(['card_state']) self.assertEqual(job.card_state, 'idle_warning') def test_no_parts(self): # confirmed job with no started steps; receiving still draft job = self.Job.create({ 'name': 'WO-PARTS', 'partner_id': self.partner.id, 'qty': 1, 'state': 'confirmed', }) with patch.object(type(job), '_fp_inbound_not_received', return_value=True): self.assertEqual(job.card_state, 'no_parts') # ---- precedence pairs --------------------------------------------- def test_on_hold_beats_awaiting_signoff(self): # Both true; on_hold (rule 2) must win. job = self._make_job_with_active_step(step_state='in_progress') with patch.object(type(job), '_fp_has_open_hold', return_value=True), \ patch.object(type(job), '_fp_has_pending_qc', return_value=True): self.assertEqual(job.card_state, 'on_hold') def test_bake_due_beats_running(self): job = self._make_job_with_active_step(step_state='in_progress') with patch.object(type(job), '_fp_bake_window_due_soon', return_value=True): self.assertEqual(job.card_state, 'bake_due') def test_idle_beats_running(self): job = self._make_job_with_active_step(step_state='in_progress') step = job.active_step_id with patch.object(type(step), '_fp_is_idle', return_value=True): job.invalidate_recordset(['card_state']) self.assertEqual(job.card_state, 'idle_warning') ``` - [ ] **Step 2: Run the failing test** ```bash # Copy test to entech and run cat K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/tests/test_card_state.py | ssh pve-worker5 "pct exec 111 -- bash -c 'cat > /mnt/extra-addons/custom/fusion_plating_jobs/tests/test_card_state.py'" ssh pve-worker5 "pct exec 111 -- su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin --test-enable --stop-after-init --log-level=test -u fusion_plating_jobs --test-tags /fusion_plating_jobs:TestCardState' 2>&1 | tail -40" ``` Expected: failures with "no attribute 'card_state'". - [ ] **Step 3: Implement the compute** In `fusion_plating_jobs/models/fp_job.py`, add the field: ```python card_state = fields.Char( string='Card State (plant view)', compute='_compute_card_state', store=True, index=True, help='One of 13 mutually-exclusive states driving the plant-view ' 'kanban card chrome. See spec §6 for the catalog and ' 'precedence rules.', ) ``` And the compute method (matches spec §9.3 / §6.2 precedence order EXACTLY): ```python @api.depends( 'state', 'active_step_id', 'active_step_id.state', 'active_step_id.requires_signoff', 'active_step_id.signoff_user_id', 'active_step_id.last_activity_at', 'active_step_id.area_kind', 'active_step_id.recipe_node_id.default_kind', # Indirect dependencies — recomputed manually when these change # via the relevant model's invalidate_recordset calls. ) def _compute_card_state(self): for job in self: # Edge: no active step at all if not job.active_step_id: if job.state == 'confirmed' and job._fp_inbound_not_received(): job.card_state = 'no_parts' else: job.card_state = 'contract_review' continue step = job.active_step_id # Rule 1 — no_parts if job._fp_inbound_not_received(): job.card_state = 'no_parts' continue # Rule 2 — on_hold if job._fp_has_open_hold(): job.card_state = 'on_hold' continue # Rule 3 — awaiting_signoff (S22) if (step.requires_signoff and step.state == 'done' and not step.signoff_user_id): job.card_state = 'awaiting_signoff' continue # Rule 4 — awaiting_qc if job._fp_has_pending_qc(): job.card_state = 'awaiting_qc' continue # Rule 5 — bake_due if job._fp_bake_window_due_soon(): job.card_state = 'bake_due' continue # Rule 6 — predecessor_locked if (step._fp_should_block_predecessors() and step._fp_has_unfinished_predecessors()): job.card_state = 'predecessor_locked' continue # Rule 7 — idle_warning (S16) if step.state == 'in_progress' and step._fp_is_idle(threshold_hours=8): job.card_state = 'idle_warning' continue # Rule 8 — done if step.area_kind == 'shipping' and job.state == 'done': job.card_state = 'done' continue # Rule 9 — contract_review if step.recipe_node_id.default_kind == 'contract_review': job.card_state = 'contract_review' continue # Rules 10/12 — running (mine vs not) if step.state == 'in_progress': job.card_state = 'running_mine' if job._fp_is_mine() else 'running' continue # Rules 11/13 — ready (mine vs not) if step.state == 'ready': job.card_state = 'ready_mine' if job._fp_is_mine() else 'ready' continue # Safe default job.card_state = 'ready' ``` - [ ] **Step 4: Run tests — should now pass** ```bash cat K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/models/fp_job.py | ssh pve-worker5 "pct exec 111 -- bash -c 'cat > /mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py'" ssh pve-worker5 "pct exec 111 -- su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin --test-enable --stop-after-init --log-level=test -u fusion_plating_jobs --test-tags /fusion_plating_jobs:TestCardState' 2>&1 | tail -40" ``` Expected: 13 of 13 tests pass. - [ ] **Step 5: Commit** ```bash git add fusion_plating_jobs/models/fp_job.py fusion_plating_jobs/tests/test_card_state.py fusion_plating_jobs/tests/__init__.py && git commit -m "feat(jobs): add fp.job.card_state for plant-view kanban 13-state classifier with explicit precedence dispatch matching spec §6.2/§9.3 exactly. Stored computed field so the kanban endpoint can index/filter on it cheaply. Tested with one assertion per state + 3 precedence-pair tests (on_hold beats awaiting_signoff, bake_due beats running, idle beats running). Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 8: Add `mini_timeline_json` compute **Files:** - Modify: `fusion_plating_jobs/models/fp_job.py` - Test: `fusion_plating_jobs/tests/test_mini_timeline.py` (create) - [ ] **Step 1: Write failing test** Create `fusion_plating_jobs/tests/test_mini_timeline.py`: ```python # -*- coding: utf-8 -*- import json from odoo.tests.common import TransactionCase class TestMiniTimeline(TransactionCase): @classmethod def setUpClass(cls): super().setUpClass() cls.Job = cls.env['fp.job'] cls.Step = cls.env['fp.job.step'] cls.Node = cls.env['fusion.plating.process.node'] cls.partner = cls.env['res.partner'].create({'name': 'T'}) def _build_recipe_job(self, step_areas): """step_areas: list of (area_kind, state). Returns the job.""" job = self.Job.create({ 'name': 'WO-TIMELINE', 'partner_id': self.partner.id, 'qty': 1, }) for i, (area, state) in enumerate(step_areas): # Build a recipe node whose default_kind routes to that area kind_map = { 'receiving': 'incoming_inspection', 'masking': 'masking', 'blasting': 'blasting', 'racking': 'racking', 'plating': 'soak_clean', 'baking': 'bake', 'de_racking': 'de_rack', 'inspection': 'final_inspection', 'shipping': 'shipping', } node = self.Node.create({ 'name': area, 'node_type': 'step', 'default_kind': kind_map[area], }) self.Step.create({ 'job_id': job.id, 'name': area, 'recipe_node_id': node.id, 'sequence': (i + 1) * 10, 'state': state, }) job.invalidate_recordset() return job def test_timeline_returns_9_elements(self): job = self._build_recipe_job([ ('receiving', 'done'), ('racking', 'in_progress'), ('plating', 'pending'), ]) timeline = json.loads(job.mini_timeline_json) self.assertEqual(len(timeline), 9) def test_timeline_order_matches_column_sequence(self): job = self._build_recipe_job([('receiving', 'done')]) timeline = json.loads(job.mini_timeline_json) areas = [t['area'] for t in timeline] self.assertEqual(areas, [ 'receiving', 'masking', 'blasting', 'racking', 'plating', 'baking', 'de_racking', 'inspection', 'shipping', ]) def test_done_areas_marked_done(self): job = self._build_recipe_job([ ('receiving', 'done'), ('masking', 'done'), ('racking', 'in_progress'), ]) timeline = json.loads(job.mini_timeline_json) by_area = {t['area']: t['state'] for t in timeline} self.assertEqual(by_area['receiving'], 'done') self.assertEqual(by_area['masking'], 'done') self.assertEqual(by_area['racking'], 'current') self.assertEqual(by_area['plating'], 'upcoming') def test_skipped_area_renders_as_upcoming(self): # Recipe has no Masking step — column still shows as upcoming job = self._build_recipe_job([ ('receiving', 'done'), ('blasting', 'done'), ('racking', 'in_progress'), ]) timeline = json.loads(job.mini_timeline_json) by_area = {t['area']: t['state'] for t in timeline} self.assertEqual(by_area['masking'], 'upcoming') ``` - [ ] **Step 2: Run the test (expected fail)** ```bash ssh pve-worker5 "pct exec 111 -- su - odoo -s /bin/bash -c '/usr/bin/odoo ... --test-tags /fusion_plating_jobs:TestMiniTimeline'" ``` Expected: AttributeError. - [ ] **Step 3: Implement the compute** Add to `fp.job`: ```python mini_timeline_json = fields.Text( string='Mini-Timeline (JSON)', compute='_compute_mini_timeline_json', help='Serialized 9-element array, one per Shop Floor column, ' 'with state in {done, current, upcoming}. Card UI reads ' 'this to render the bottom timeline strip.', ) _COLUMN_SEQUENCE = [ 'receiving', 'masking', 'blasting', 'racking', 'plating', 'baking', 'de_racking', 'inspection', 'shipping', ] @api.depends( 'step_ids.state', 'step_ids.area_kind', 'active_step_id', 'card_state', ) def _compute_mini_timeline_json(self): import json as _json for job in self: active_area = job.active_step_id.area_kind if job.active_step_id else None timeline = [] for area in self._COLUMN_SEQUENCE: steps_in_area = job.step_ids.filtered(lambda s: s.area_kind == area) if not steps_in_area: # Recipe doesn't visit this area timeline.append({'area': area, 'state': 'upcoming'}) continue if all(s.state in ('done', 'skipped') for s in steps_in_area): timeline.append({'area': area, 'state': 'done'}) elif area == active_area: timeline.append({ 'area': area, 'state': 'current', 'variant': job.card_state, }) else: timeline.append({'area': area, 'state': 'upcoming'}) job.mini_timeline_json = _json.dumps(timeline) ``` - [ ] **Step 4: Run the test** Expected: all 4 tests pass. - [ ] **Step 5: Commit** ```bash git add fusion_plating_jobs/models/fp_job.py fusion_plating_jobs/tests/test_mini_timeline.py && git commit -m "feat(jobs): add fp.job.mini_timeline_json for plant-view card 9-element JSON array, one per Shop Floor column, with state in {done, current, upcoming}. Powers the bottom timeline strip on each card without the frontend needing to know recipe shape. The 'current' entry carries the card's variant (e.g. 'on_hold', 'bake_due') so the renderer picks the right color for the highlighted column marker. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ## Phase 3 — Backend endpoint ### Task 9: Create `/fp/landing/plant_kanban` controller **Files:** - Create: `fusion_plating_shopfloor/controllers/plant_kanban.py` - Modify: `fusion_plating_shopfloor/controllers/__init__.py` - Test: `fusion_plating_shopfloor/tests/test_plant_kanban_endpoint.py` (create) - [ ] **Step 1: Add to controllers package init** In `fusion_plating_shopfloor/controllers/__init__.py`: ```python from . import plant_kanban ``` (Add this line; keep existing imports.) - [ ] **Step 2: Implement the endpoint** Create `fusion_plating_shopfloor/controllers/plant_kanban.py`: ```python # -*- coding: utf-8 -*- # Plant-view kanban endpoint. Returns columns + denormalized cards in # one payload so the OWL component doesn't need to fan out RPCs. from odoo import http, _ from odoo.http import request import json import logging _logger = logging.getLogger(__name__) _COLUMN_LABELS = [ ('receiving', _('Receiving')), ('masking', _('Masking')), ('blasting', _('Blasting')), ('racking', _('Racking')), ('plating', _('Plating')), ('baking', _('Baking')), ('de_racking', _('De-Racking')), ('inspection', _('Final inspection')), ('shipping', _('Shipping')), ] class PlantKanbanController(http.Controller): @http.route('/fp/landing/plant_kanban', type='jsonrpc', auth='user') def plant_kanban(self, mode='station', filters=None): """Returns the assembled board payload. mode: 'station' | 'all_plant' | 'manager' filters: optional dict, e.g. {'overdue': True, 'fair': True} """ user = request.env.user Job = request.env['fp.job'] # Find paired station (for 'mine' resolution + column highlight) paired = user.paired_work_centre_ids[:1] if ( 'paired_work_centre_ids' in user._fields ) else request.env['fp.work.centre'] paired_area = paired.area_kind if paired else None # Build base domain — every job with at least one non-terminal step domain = [ ('state', 'in', ('confirmed', 'in_progress')), ('active_step_id', '!=', False), ] # Apply optional filters filters = filters or {} if filters.get('overdue'): from datetime import date domain.append(('commitment_date', '<', date.today())) if filters.get('on_hold'): domain.append(('card_state', '=', 'on_hold')) if filters.get('running'): domain.append(('active_step_id.state', '=', 'in_progress')) if filters.get('blocked'): domain.append(('card_state', 'in', ( 'on_hold', 'predecessor_locked', 'awaiting_signoff', 'awaiting_qc', 'no_parts', ))) if filters.get('mine') and paired: domain.append(('card_state', 'in', ('ready_mine', 'running_mine'))) if filters.get('fair'): # Wire to whatever flag denotes FAIR — partner or customer_spec # Adjust to your data model: domain.append(('customer_spec_id.x_fc_requires_first_article', '=', True)) jobs = Job.search(domain, limit=500) # Group by area_kind cards = {} cards_by_area = {area: [] for area, _label in _COLUMN_LABELS} for job in jobs: area = job.active_step_id.area_kind or 'plating' cards_by_area.setdefault(area, []).append(job.id) cards[str(job.id)] = self._render_card(job, user, paired) columns = [] for area, label in _COLUMN_LABELS: columns.append({ 'area_kind': area, 'label': label, 'is_mine': (area == paired_area), 'card_ids': sorted( cards_by_area.get(area, []), key=lambda jid: self._sort_key(cards[str(jid)]), ), }) # KPIs kpis = self._compute_kpis(jobs, paired) return { 'ok': True, 'mode': mode, 'paired_station': { 'id': paired.id, 'name': paired.name, 'area_kind': paired_area, } if paired else None, 'kpis': kpis, 'columns': columns, 'cards': cards, } def _render_card(self, job, user, paired): """Build the full card payload for a single fp.job.""" step = job.active_step_id timeline = json.loads(job.mini_timeline_json or '[]') return { 'wo_name': job.display_wo_name or job.name, 'is_mine': job.card_state in ('ready_mine', 'running_mine'), 'card_state': job.card_state, 'due_date': fields_isoformat(job.commitment_date), 'due_label': self._due_label(job.commitment_date), 'is_overdue': self._is_overdue(job.commitment_date), 'customer': job.partner_id.name, 'part_number': ( job.part_catalog_id.part_number if 'part_catalog_id' in job._fields and job.part_catalog_id else '' ), 'part_revision': ( job.part_catalog_id.revision if 'part_catalog_id' in job._fields and job.part_catalog_id else '' ), 'qty': job.qty, 'po_number': ( job.sale_order_id.x_fc_po_number if job.sale_order_id and 'x_fc_po_number' in job.sale_order_id._fields else '' ), 'recipe_name': job.recipe_id.name if job.recipe_id else '', 'spec_code': ( job.customer_spec_id.code if 'customer_spec_id' in job._fields and job.customer_spec_id else '' ), 'tags': self._compute_tags(job), 'step_name': step.name if step else '', 'step_seq': step.sequence if step else 0, 'step_total': len(job.step_ids), 'tank_label': ( step.work_centre_id.name if step and step.work_centre_id else '' ), 'state_chip': self._state_chip(job.card_state, step), 'operator': self._operator_payload(step), 'duration_label': self._duration_label(step), 'icons': self._icons(job, step), 'mini_timeline': timeline, } def _compute_tags(self, job): tags = [] partner = job.partner_id if 'x_fc_rush' in partner._fields and partner.x_fc_rush: tags.append('rush') if 'x_fc_vip' in partner._fields and partner.x_fc_vip: tags.append('vip') spec = job.customer_spec_id if 'customer_spec_id' in job._fields else None if spec and 'x_fc_requires_first_article' in spec._fields \ and spec.x_fc_requires_first_article: tags.append('fair') return tags def _state_chip(self, card_state, step): """Returns {'label': ..., 'kind': ...} for the state chip.""" # ... implement per spec §6.1; one map keyed by card_state. chips = { 'ready': {'label': _('● Ready'), 'kind': 'ready'}, 'ready_mine': {'label': _('● Ready to start'), 'kind': 'ready'}, 'running': self._running_chip(step), 'running_mine': self._running_chip(step), 'on_hold': {'label': _('🔴 Quality Hold'), 'kind': 'hold'}, 'awaiting_signoff': {'label': _('🔏 Awaiting QA sign-off'), 'kind': 'signoff'}, 'awaiting_qc': self._qc_chip(step), 'bake_due': self._bake_chip(step), 'predecessor_locked': self._lock_chip(step), 'idle_warning': self._idle_chip(step), 'no_parts': self._no_parts_chip(step), 'contract_review': {'label': _('📋 QA-005 Awaiting'), 'kind': 'paperwork'}, 'done': {'label': _('✓ Ready for pickup'), 'kind': 'done'}, } return chips.get(card_state, {'label': '', 'kind': ''}) def _running_chip(self, step): elapsed = self._elapsed_label(step) return {'label': _('▶ Running %s') % elapsed, 'kind': 'running'} def _idle_chip(self, step): elapsed = self._elapsed_hours(step) # Find last operator from timelogs or step.assigned_user_id op_name = step.assigned_user_id.name.split()[0] if step.assigned_user_id else _('Operator') return { 'label': _('⏸ Idle %dh · %s') % (elapsed, op_name), 'kind': 'idle', } # ... additional small helpers ... def _sort_key(self, card): """Sort within column: overdue → bake_due → ready → running → idle → locked → done.""" priority = { 'on_hold': 0, 'no_parts': 1, 'bake_due': 2, 'awaiting_signoff': 3, 'awaiting_qc': 4, 'ready_mine': 5, 'running_mine': 6, 'ready': 7, 'running': 8, 'idle_warning': 9, 'predecessor_locked': 10, 'contract_review': 11, 'done': 12, } return ( 0 if card['is_overdue'] else 1, priority.get(card['card_state'], 99), card['due_date'] or '9999-12-31', ) def _compute_kpis(self, jobs, paired): return { 'active_jobs': len(jobs), 'at_my_station': sum(1 for j in jobs if j.card_state in ('ready_mine', 'running_mine')), 'bakes_due_soon': sum(1 for j in jobs if j.card_state == 'bake_due'), 'on_hold': sum(1 for j in jobs if j.card_state == 'on_hold'), 'overdue': sum(1 for j in jobs if self._is_overdue(j.commitment_date)), } ``` The skeleton above shows the structure. Fill in the remaining tiny helpers (`_due_label`, `_is_overdue`, `_elapsed_label`, `_elapsed_hours`, `_operator_payload`, `_duration_label`, `_icons`, `_qc_chip`, `_bake_chip`, `_lock_chip`, `_no_parts_chip`) — each is 3-8 lines, all string formatting. - [ ] **Step 3: Add a basic integration test** Create `fusion_plating_shopfloor/tests/test_plant_kanban_endpoint.py`: ```python # -*- coding: utf-8 -*- from odoo.tests.common import HttpCase, tagged @tagged('-at_install', 'post_install') class TestPlantKanbanEndpoint(HttpCase): def test_endpoint_returns_9_columns(self): self.authenticate('admin', 'admin') result = self.url_open( '/fp/landing/plant_kanban', data='{"jsonrpc":"2.0","method":"call","params":{}}', headers={'Content-Type': 'application/json'}, ) body = result.json()['result'] self.assertTrue(body['ok']) self.assertEqual(len(body['columns']), 9) areas = [c['area_kind'] for c in body['columns']] self.assertEqual(areas, [ 'receiving', 'masking', 'blasting', 'racking', 'plating', 'baking', 'de_racking', 'inspection', 'shipping', ]) def test_card_payload_has_required_fields(self): # Set up a job, then verify card payload structure # ... (full setup with partner, recipe, etc.) pass ``` - [ ] **Step 4: Run the endpoint test** ```bash ssh pve-worker5 "pct exec 111 -- su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin --test-enable --stop-after-init -u fusion_plating_shopfloor --test-tags /fusion_plating_shopfloor:TestPlantKanbanEndpoint' 2>&1 | tail -30" ``` Expected: tests pass; 9 columns in correct order. - [ ] **Step 5: Commit** ```bash git add fusion_plating_shopfloor/controllers/ fusion_plating_shopfloor/tests/test_plant_kanban_endpoint.py && git commit -m "feat(shopfloor): /fp/landing/plant_kanban endpoint JSONRPC endpoint returning {kpis, columns, cards} for the plant- view kanban. Columns are always the same 9 in process sequence; cards are denormalized per spec §9.2 so the OWL component doesn't fan out per-card RPCs. Includes within-column sort (overdue → bake_due → ready → running → idle → locked → done) and basic filter handling (overdue, on_hold, running, blocked, mine, fair). Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 10: Update landing action resolver for v2 dispatch **Files:** - Modify: `fusion_plating/data/fp_landing_data.xml` (the ir.actions.server `action_fp_resolve_plating_landing`) OR wherever the resolver lives. Confirm via: ```bash grep -rn "action_fp_resolve_plating_landing\|fp_shopfloor_landing\|fp_plant_kanban" K:/Github/Odoo-Modules/fusion_plating/fusion_plating/ K:/Github/Odoo-Modules/fusion_plating/fusion_plating_shopfloor/ 2>/dev/null | head -10 ``` - [ ] **Step 1: Find the existing client action registration for `fp_shopfloor_landing`** ```bash grep -rn "fp_shopfloor_landing\|fp.shopfloor.landing" K:/Github/Odoo-Modules/fusion_plating/fusion_plating_shopfloor/ 2>/dev/null | head ``` The action probably lives in a data XML file. We'll add a new client action `fp_plant_kanban` and have the resolver pick between them. - [ ] **Step 2: Add the new client action data** In the same XML file where `fp_shopfloor_landing` is registered, add: ```xml Shop Floor fp_plant_kanban main ``` - [ ] **Step 3: Update the resolver to read the feature flag** If the resolver is an `ir.actions.server` with Python code, update it: ```python # ir.actions.server.code — runs when user opens the landing action ICP = env['ir.config_parameter'].sudo() layout = ICP.get_param('fusion_plating_shopfloor.layout', default='legacy') # User override still wins if set (existing logic): if env.user.x_fc_plating_landing_action_id: action = env.user.x_fc_plating_landing_action_id.read()[0] elif env.company.x_fc_default_landing_action_id: action = env.company.x_fc_default_landing_action_id.read()[0] else: # Default: dispatch by feature flag if layout == 'v2': action = env.ref('fusion_plating_shopfloor.action_fp_plant_kanban').read()[0] else: action = env.ref('fusion_plating_shopfloor.action_fp_shopfloor_landing').read()[0] ``` (Locate the exact existing resolver code and merge the dispatch logic in.) - [ ] **Step 4: Smoke test** Set the config parameter to `v2`: ```bash ssh pve-worker5 "pct exec 111 -- su - postgres -c \"psql -d admin -c \\\"INSERT INTO ir_config_parameter (key, value, write_uid, create_uid, write_date, create_date) VALUES ('fusion_plating_shopfloor.layout', 'v2', 1, 1, now(), now()) ON CONFLICT (key) DO UPDATE SET value = 'v2';\\\"\"" ``` Open the Plating app. Confirm: clicking the root menu hits the resolver and returns the new client action. Since the frontend isn't built yet, you'll see an "Action not found" error — that's expected. Set the param back to `legacy` to use the existing UI while we build v2. - [ ] **Step 5: Commit** ```bash git add fusion_plating_shopfloor/data/ fusion_plating/data/fp_landing_data.xml && git commit -m "feat(shopfloor): dispatch landing action by x_fc_shopfloor_layout Registers the new fp_plant_kanban client action and teaches the landing resolver to pick between legacy and v2 based on the ir.config_parameter set by the new feature-flag setting. User-level and company-level overrides still win (existing behaviour). Default to legacy until the v2 frontend ships. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ## Phase 4 — Frontend components (bottom-up) ### Task 11: SCSS design tokens **Files:** - Create: `fusion_plating_shopfloor/static/src/scss/_plant_tokens.scss` **Critical:** Register this FIRST in the manifest's `web.assets_backend` (before any consumer SCSS). Per CLAUDE.md rule 8, SCSS files are concatenated in manifest order; tokens must precede consumers. - [ ] **Step 1: Create the tokens file** ```scss // ===================================================================== // Plant-view kanban — design tokens // MUST load before _plant_card.scss, _mini_timeline.scss, etc. // Per the project rule: @import in custom SCSS is forbidden in Odoo 19. // ===================================================================== $o-webclient-color-scheme: bright !default; // === Card-state colors (light mode defaults) === $_plant-bg-hex: #f8f9fa; $_plant-card-bg-hex: #ffffff; $_plant-card-border-hex: #d8dadd; $_plant-text-hex: #1d1f1e; $_plant-muted-hex: #777; $_plant-mine-bg-hex: #fffaeb; $_plant-mine-border-hex: #f0a500; $_plant-hold-bg-hex: #fff5f5; $_plant-hold-border-hex: #dc3545; $_plant-bake-bg-hex: #fff8e1; $_plant-bake-border-hex: #ff9800; $_plant-signoff-bg-hex: #f5f0ff; $_plant-signoff-border-hex: #6f42c1; $_plant-idle-bg-hex: #fef9e7; $_plant-idle-border-hex: #e6a800; $_plant-qc-bg-hex: #e7f5fc; $_plant-qc-border-hex: #17a2b8; $_plant-locked-bg-hex: #f8f9fa; $_plant-noparts-bg-hex: #f5f5f5; $_plant-noparts-border-hex: #6c757d; $_plant-done-bg-hex: #f0f9f4; $_plant-done-border-hex: #28a745; @if $o-webclient-color-scheme == dark { $_plant-bg-hex: #1a1d21 !global; $_plant-card-bg-hex: #22262d !global; $_plant-card-border-hex: #424245 !global; $_plant-text-hex: #f5f5f7 !global; $_plant-muted-hex: #adb5bd !global; $_plant-mine-bg-hex: #3a2f10 !global; $_plant-hold-bg-hex: #3a1e1e !global; $_plant-bake-bg-hex: #3a2f10 !global; $_plant-signoff-bg-hex: #1f1730 !global; $_plant-idle-bg-hex: #2d2818 !global; $_plant-qc-bg-hex: #14252e !global; $_plant-locked-bg-hex: #2d3138 !global; $_plant-noparts-bg-hex: #2d3138 !global; $_plant-done-bg-hex: #14281a !global; } // Wrap each in a CSS custom property so future themes can override. $plant-bg: var(--fp-plant-bg, $_plant-bg-hex); $plant-card-bg: var(--fp-plant-card-bg, $_plant-card-bg-hex); $plant-card-border: var(--fp-plant-card-border, $_plant-card-border-hex); $plant-text: var(--fp-plant-text, $_plant-text-hex); $plant-muted: var(--fp-plant-muted, $_plant-muted-hex); $plant-mine-bg: var(--fp-plant-mine-bg, $_plant-mine-bg-hex); $plant-mine-border: var(--fp-plant-mine-border, $_plant-mine-border-hex); // ... (same pattern for every other color) ``` - [ ] **Step 2: Register in manifest BEFORE any consumer SCSS** In `fusion_plating_shopfloor/__manifest__.py` `'web.assets_backend':` list, add the tokens FIRST in the plant-view group: ```python 'web.assets_backend': [ # ... existing entries ... # ---- Plant view (2026-05-23) ---- TOKENS FIRST! 'fusion_plating_shopfloor/static/src/scss/_plant_tokens.scss', 'fusion_plating_shopfloor/static/src/scss/components/_plant_card.scss', 'fusion_plating_shopfloor/static/src/scss/components/_mini_timeline.scss', 'fusion_plating_shopfloor/static/src/scss/components/_column_header.scss', 'fusion_plating_shopfloor/static/src/scss/components/_kpi_tile.scss', 'fusion_plating_shopfloor/static/src/scss/components/_filter_chip.scss', 'fusion_plating_shopfloor/static/src/scss/plant_kanban.scss', # XML templates 'fusion_plating_shopfloor/static/src/xml/components/plant_card.xml', 'fusion_plating_shopfloor/static/src/xml/components/mini_timeline.xml', 'fusion_plating_shopfloor/static/src/xml/components/column_header.xml', 'fusion_plating_shopfloor/static/src/xml/components/kpi_tile.xml', 'fusion_plating_shopfloor/static/src/xml/components/filter_chip.xml', 'fusion_plating_shopfloor/static/src/xml/plant_kanban.xml', # JS 'fusion_plating_shopfloor/static/src/js/components/mini_timeline.js', 'fusion_plating_shopfloor/static/src/js/components/plant_card.js', 'fusion_plating_shopfloor/static/src/js/components/column_header.js', 'fusion_plating_shopfloor/static/src/js/components/kpi_tile.js', 'fusion_plating_shopfloor/static/src/js/components/filter_chip.js', 'fusion_plating_shopfloor/static/src/js/plant_kanban.js', ], ``` Mirror the same list under `'web.assets_web_dark'` so dark mode picks up the same files (each gets compiled with `$o-webclient-color-scheme: dark`). - [ ] **Step 3: Verify the bundle compiles** ```bash ssh pve-worker5 "pct exec 111 -- bash -c 'systemctl stop odoo && su - odoo -s /bin/bash -c \"/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_shopfloor --stop-after-init\" 2>&1 | grep -E \"(ERROR|asset|loaded fusion_plating_shopfloor)\" | tail -10 && systemctl start odoo'" ``` No SCSS errors expected. (Files are empty stubs at this point but tokens compile fine.) - [ ] **Step 4: Commit** ```bash git add fusion_plating_shopfloor/static/src/scss/_plant_tokens.scss fusion_plating_shopfloor/__manifest__.py && git commit -m "feat(shopfloor): plant-view SCSS design tokens Tokens file for the plant-view card states. Loads first in the manifest assets list so subsequent SCSS files can reference the variables (per the project's no-@import rule). Dark-mode branch via \$o-webclient-color-scheme so the same source compiles into both bundles correctly. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 12: Mini-timeline OWL component **Files:** - Create: `fusion_plating_shopfloor/static/src/js/components/mini_timeline.js` - Create: `fusion_plating_shopfloor/static/src/xml/components/mini_timeline.xml` - Create: `fusion_plating_shopfloor/static/src/scss/components/_mini_timeline.scss` - [ ] **Step 1: Component JS** ```javascript /** @odoo-module **/ // ===================================================================== // FpMiniTimeline — horizontal 9-step bar showing where the job is in // its journey across the Shop Floor columns. Used by FpPlantCard. // ===================================================================== import { Component } from "@odoo/owl"; export class FpMiniTimeline extends Component { static template = "fusion_plating_shopfloor.MiniTimeline"; static props = { timeline: { type: Array }, // 9-element array from server }; // Label shown under each step (3-4 char abbreviation) static AREA_LABELS = { receiving: "Rec", masking: "Mask", blasting: "Blast", racking: "Rack", plating: "Plat", baking: "Bake", de_racking: "D-R", inspection: "Insp", shipping: "Ship", }; labelFor(area) { return this.constructor.AREA_LABELS[area] || area; } classFor(entry) { if (entry.state === "done") return "tl-step done"; if (entry.state === "current") { const variant = entry.variant || ""; return `tl-step current ${variant.replace("_mine", "").replace("_", "-")}`; } return "tl-step"; } } ``` - [ ] **Step 2: Template XML** ```xml
``` **Note:** uses `entry.area` directly (no `String()` call). The template accesses props/state/component getters; no global JS function calls. - [ ] **Step 3: SCSS** ```scss // _mini_timeline.scss — depends on _plant_tokens.scss being loaded first .o_fp_mini_timeline { display: flex; flex-direction: column; gap: 2px; .tl-row { display: flex; gap: 2px; padding: 2px 0; .tl-step { flex: 1; height: 8px; background: #e5e7eb; border-radius: 1.5px; transition: background 0.1s ease; cursor: help; &.done { background: #28a745; } &.current { background: #f0a500; height: 11px; margin-top: -1.5px; box-shadow: 0 0 0 1px rgba(240, 165, 0, 0.25); &.hold { background: #dc3545; box-shadow: 0 0 0 1px rgba(220, 53, 69, .25); } &.locked { background: #6c757d; } &.bake { background: #ff9800; } &.signoff { background: #6f42c1; } &.idle { background: #e6a800; } &.qc { background: #17a2b8; } &.no-parts { background: #6c757d; border: 1px dashed #999; } &.done { background: #28a745; } &.paperwork { background: #6f42c1; } &.contract-review { background: #6f42c1; } } } } .tl-labels { display: flex; gap: 2px; font-size: 8px; color: $plant-muted; text-transform: uppercase; letter-spacing: 0.03em; span { flex: 1; text-align: center; &.current { color: $plant-mine-border; font-weight: 700; } } } } @if $o-webclient-color-scheme == dark { .o_fp_mini_timeline .tl-row .tl-step { background: #2d3138; } } ``` - [ ] **Step 4: Commit** ```bash git add fusion_plating_shopfloor/static/src/js/components/mini_timeline.js fusion_plating_shopfloor/static/src/xml/components/mini_timeline.xml fusion_plating_shopfloor/static/src/scss/components/_mini_timeline.scss && git commit -m "feat(shopfloor): FpMiniTimeline OWL component 9-step horizontal bar showing where the job is in its journey across the Shop Floor columns. Consumes the mini_timeline JSON output of fp.job.mini_timeline_json. Per project rule 20: no String()/Number() calls inside templates; classFor() and labelFor() do the formatting in JS. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 13: Plant card OWL component **Files:** - Create: `fusion_plating_shopfloor/static/src/js/components/plant_card.js` - Create: `fusion_plating_shopfloor/static/src/xml/components/plant_card.xml` - Create: `fusion_plating_shopfloor/static/src/scss/components/_plant_card.scss` - [ ] **Step 1: Component JS** ```javascript /** @odoo-module **/ import { Component, markup } from "@odoo/owl"; import { useService } from "@web/core/utils/hooks"; import { FpMiniTimeline } from "./mini_timeline"; export class FpPlantCard extends Component { static template = "fusion_plating_shopfloor.PlantCard"; static components = { FpMiniTimeline }; static props = { card: { type: Object }, // Full card payload from /fp/landing/plant_kanban }; setup() { this.action = useService("action"); } get cardClass() { // Returns the CSS class string for the card's state. // Multiple state classes can apply (e.g. 'mine' + a state-specific // chrome) so we compose here rather than in the template. const card = this.props.card; const classes = ["o_fp_plant_card", `state-${card.card_state}`]; if (card.is_mine) classes.push("mine"); if (card.is_overdue) classes.push("overdue"); return classes.join(" "); } get progressPercent() { const card = this.props.card; if (!card.step_total) return 0; return Math.round((card.step_seq / card.step_total) * 100); } onCardClick() { // Opens Job Workspace for this WO. this.action.doAction({ type: "ir.actions.client", tag: "fp_job_workspace", target: "current", params: { job_id: this.props.card.job_id }, }); } } ``` - [ ] **Step 2: Template XML** ```xml
⭐
⚠
PN Rev · Qty · PO
Recipe: ·
/
``` **Template scope check (Rule 20):** `tag.toUpperCase()` — `toUpperCase()` is a method on the string instance, not a global function call. Safe. No `String(...)` or `Number(...)` calls. - [ ] **Step 3: SCSS — all 13 card states** ```scss // _plant_card.scss — depends on _plant_tokens.scss .o_fp_plant_card { background: $plant-card-bg; border: 1px solid $plant-card-border; border-radius: 8px; padding: 12px; display: flex; flex-direction: column; gap: 6px; cursor: pointer; transition: transform 0.1s, box-shadow 0.1s; box-shadow: 0 1px 2px rgba(0,0,0,0.04); width: 100%; box-sizing: border-box; &:hover { transform: translateY(-1px); box-shadow: 0 3px 8px rgba(0,0,0,0.12); } // === Card state chrome === &.mine, &.state-ready_mine, &.state-running_mine { background: $plant-mine-bg; border-left: 4px solid $plant-mine-border; padding-left: 9px; } &.state-on_hold { background: $plant-hold-bg; border-left: 4px solid $plant-hold-border; padding-left: 9px; } &.state-bake_due { background: $plant-bake-bg; border-left: 4px solid $plant-bake-border; padding-left: 9px; } &.state-awaiting_signoff { background: $plant-signoff-bg; border-left: 4px solid $plant-signoff-border; padding-left: 9px; } &.state-idle_warning { background: $plant-idle-bg; border-left: 4px solid $plant-idle-border; padding-left: 9px; } &.state-awaiting_qc { background: $plant-qc-bg; border-left: 4px solid $plant-qc-border; padding-left: 9px; } &.state-predecessor_locked { background: $plant-locked-bg; } &.state-no_parts { background: $plant-noparts-bg; border: 1px dashed #999; border-left: 4px solid $plant-noparts-border; padding-left: 9px; } &.state-done { background: $plant-done-bg; border-left: 4px solid $plant-done-border; padding-left: 9px; } &.overdue:not(.mine):not(.state-on_hold):not(.state-bake_due) { border-left: 4px solid $plant-hold-border; padding-left: 9px; } // === Sub-elements === .card-top { display: flex; align-items: baseline; justify-content: space-between; gap: 8px; } .card-wo { font-size: 16px; font-weight: 700; color: $plant-text; } .card-due { font-size: 11px; color: $plant-muted; white-space: nowrap; } .card-due.overdue { color: $plant-hold-border; font-weight: 700; } .card-sub { font-size: 12px; color: $plant-muted; line-height: 1.35; } .card-sub-em { color: $plant-text; font-weight: 600; } .card-meta { font-size: 11px; color: $plant-muted; } .card-step { font-size: 14px; font-weight: 600; color: $plant-text; } .card-chips { display: flex; flex-wrap: wrap; gap: 4px; } .chip { font-size: 11px; padding: 2px 8px; border-radius: 12px; background: #f1f3f5; color: #4e4e4e; border: 1px solid #e5e7eb; &.tank { background: #e7f1ff; color: #0d4a8c; border-color: #cfe2ff; } &.state-ready { background: #d1ecf1; color: #0c5460; border-color: #bee5eb; font-weight: 600; } &.state-running { background: #fff3cd; color: #856404; border-color: #ffeeba; font-weight: 600; } &.state-hold { background: #f8d7da; color: #721c24; border-color: #f5c6cb; font-weight: 700; } &.state-locked { background: #e2e3e5; color: #383d41; border-color: #d6d8db; font-weight: 600; } &.state-due { background: #ffe9c6; color: #8a4a00; border-color: #ffd28a; font-weight: 700; } &.state-signoff { background: #e8d9ff; color: #4a2db0; border-color: #d4c5ff; font-weight: 700; } &.state-idle { background: #fff3cd; color: #856404; border-color: #ffeeba; font-weight: 700; } &.state-qc { background: #c4e9f3; color: #0c5460; border-color: #a8dde9; font-weight: 700; } &.state-no_parts { background: #e2e3e5; color: #383d41; border-color: #d6d8db; font-weight: 700; } &.state-done { background: #d4edda; color: #155724; border-color: #c3e6cb; font-weight: 700; } &.state-paperwork { background: #e8e0ff; color: #4a2db0; border-color: #d4c5ff; font-weight: 600; } &.tag-rush { background: #ffe5e5; color: #b00; border-color: #ffcfcf; font-weight: 700; font-size: 10px; } &.tag-fair { background: #fff0d9; color: #8a4a00; border-color: #ffe0b3; font-weight: 700; font-size: 10px; } &.tag-vip { background: #e8e0ff; color: #4a2db0; border-color: #d4c5ff; font-weight: 700; font-size: 10px; } } .card-bottom { display: flex; align-items: center; justify-content: space-between; gap: 8px; padding-top: 6px; border-top: 1px solid #f1f3f5; font-size: 11px; color: $plant-muted; } .progress { display: flex; align-items: center; gap: 6px; flex: 1; } .progress-bar { flex: 1; max-width: 100px; height: 4px; background: #e5e7eb; border-radius: 2px; overflow: hidden; } .progress-fill { height: 100%; background: $plant-mine-border; border-radius: 2px; } .operator-pill { display: inline-flex; align-items: center; background: #f1f3f5; border-radius: 10px; padding: 0 4px; font-size: 11px; border: 1px solid #e5e7eb; } .operator-avatar { width: 14px; height: 14px; border-radius: 50%; background: #4caf50; color: #fff; font-size: 9px; font-weight: 700; display: inline-flex; align-items: center; justify-content: center; } .icon-row { display: flex; gap: 6px; font-size: 12px; } } @if $o-webclient-color-scheme == dark { .o_fp_plant_card .card-bottom { border-top-color: #424245; } // ... dark-mode chip overrides as needed } ``` - [ ] **Step 4: Smoke-test the bundle compiles** ```bash # After copying files to entech and bumping shopfloor version + upgrading ssh pve-worker5 "pct exec 111 -- bash -c 'systemctl stop odoo && su - odoo -s /bin/bash -c \"/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_shopfloor --stop-after-init\" 2>&1 | grep -iE \"(error|asset)\" | tail -10 && systemctl start odoo'" ``` Then bust the asset cache: ```bash ssh pve-worker5 "pct exec 111 -- su - postgres -c \"psql -d admin -c \\\"DELETE FROM ir_attachment WHERE url LIKE '/web/assets/%';\\\"\"" ``` - [ ] **Step 5: Commit** ```bash git add fusion_plating_shopfloor/static/src/js/components/plant_card.js fusion_plating_shopfloor/static/src/xml/components/plant_card.xml fusion_plating_shopfloor/static/src/scss/components/_plant_card.scss && git commit -m "feat(shopfloor): FpPlantCard OWL component Variant C card per spec §5. Renders WO header, customer / part / qty / PO, recipe + spec, tag chips, current step, tank + state chip, mini-timeline, and progress/operator/icon footer. All 13 card states styled via state-{name} CSS classes. Mine detection composes with state class (e.g. .mine.state-running_mine). No String()/Number() calls in templates per project rule 20. Card tap opens fp_job_workspace with job_id pre-loaded. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 14: Column header component **Files:** - Create: `js/components/column_header.js`, `xml/components/column_header.xml`, `scss/components/_column_header.scss` - [ ] **Step 1: JS** ```javascript /** @odoo-module **/ import { Component } from "@odoo/owl"; export class FpColumnHeader extends Component { static template = "fusion_plating_shopfloor.ColumnHeader"; static props = { column: { type: Object }, // { area_kind, label, is_mine, card_ids } }; get cardCount() { return this.props.column.card_ids.length; } } ``` - [ ] **Step 2: XML** ```xml
📍 You're here
``` - [ ] **Step 3: SCSS** ```scss .o_fp_col_header { padding: 8px 12px; display: flex; align-items: center; justify-content: space-between; gap: 8px; background: $plant-card-bg; border: 1px solid $plant-card-border; border-radius: 6px 6px 0 0; &.mine { background: linear-gradient(180deg, $plant-mine-bg 0%, $plant-card-bg 100%); border-color: $plant-mine-border; } .col-meta { display: flex; flex-direction: column; gap: 2px; } .mine-badge { font-size: 11px; font-weight: 700; color: $plant-mine-border; text-transform: uppercase; letter-spacing: 0.04em; } .col-name { font-size: 15px; font-weight: 700; color: $plant-text; } .col-count { font-size: 16px; font-weight: 700; color: $plant-muted; background: $plant-card-bg; padding: 1px 8px; border-radius: 12px; border: 1px solid $plant-card-border; } &.mine .col-count { background: $plant-card-bg; border-color: $plant-mine-border; color: $plant-mine-border; } } ``` - [ ] **Step 4: Commit** ```bash git add fusion_plating_shopfloor/static/src/js/components/column_header.js fusion_plating_shopfloor/static/src/xml/components/column_header.xml fusion_plating_shopfloor/static/src/scss/components/_column_header.scss && git commit -m "feat(shopfloor): FpColumnHeader OWL component Header for each kanban column. Shows the column label, card count, and a '📍 You're here' badge when the column matches the operator's paired station. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 15: KPI tile component **Files:** - Create: `js/components/kpi_tile.js`, `xml/components/kpi_tile.xml`, `scss/components/_kpi_tile.scss` - [ ] **Step 1: JS** ```javascript /** @odoo-module **/ import { Component } from "@odoo/owl"; export class FpKpiTile extends Component { static template = "fusion_plating_shopfloor.KpiTile"; static props = { value: { type: Number }, label: { type: String }, kind: { type: String, optional: true }, // 'urgent' | 'warn' | 'good' | '' active: { type: Boolean, optional: true }, onClick: { type: Function, optional: true }, }; get tileClass() { const classes = ["o_fp_kpi_tile"]; if (this.props.kind) classes.push(this.props.kind); if (this.props.active) classes.push("active"); return classes.join(" "); } onClick() { if (this.props.onClick) this.props.onClick(); } } ``` - [ ] **Step 2: XML** ```xml ``` - [ ] **Step 3: SCSS** ```scss .o_fp_kpi_tile { padding: 8px 12px; background: $plant-card-bg; border-radius: 6px; border: 1px solid $plant-card-border; display: flex; flex-direction: column; gap: 2px; cursor: pointer; transition: background 0.1s; text-align: left; &:hover { background: $plant-bg; } &.active { border-color: $plant-mine-border; background: $plant-mine-bg; } &.urgent .kpi-val { color: $plant-hold-border; } &.warn .kpi-val { color: $plant-idle-border; } &.good .kpi-val { color: $plant-done-border; } .kpi-val { font-size: 22px; font-weight: 700; color: $plant-text; line-height: 1; } .kpi-lbl { font-size: 10px; font-weight: 600; color: $plant-muted; text-transform: uppercase; letter-spacing: 0.04em; } } ``` - [ ] **Step 4: Commit** ```bash git add fusion_plating_shopfloor/static/src/js/components/kpi_tile.js fusion_plating_shopfloor/static/src/xml/components/kpi_tile.xml fusion_plating_shopfloor/static/src/scss/components/_kpi_tile.scss && git commit -m "feat(shopfloor): FpKpiTile OWL component Clickable KPI tile for the sticky header. Color variants (urgent / warn / good) for at-a-glance severity. Active state shows when the tile is currently applying a filter to the board. Co-Authored-By: Claude Opus 4.7 (1M context) " ``` --- ### Task 16: Filter chip component **Files:** - Create: `js/components/filter_chip.js`, `xml/components/filter_chip.xml`, `scss/components/_filter_chip.scss` - [ ] **Step 1: JS** ```javascript /** @odoo-module **/ import { Component } from "@odoo/owl"; export class FpFilterChip extends Component { static template = "fusion_plating_shopfloor.FilterChip"; static props = { label: { type: String }, active: { type: Boolean }, onToggle: { type: Function }, }; onClick() { this.props.onToggle(); } } ``` - [ ] **Step 2: XML** ```xml
—