admin/Odoo-Modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(iot): repackaged Odoo iot modules + Fusion Plating sensor wrapper

Browse Source 
Phase A of the IoT initiative — gets the server-side infrastructure
in place before the Raspberry Pi hardware arrives, so the iot admin
UI + /fp/iot/ingest endpoint are ready to accept the first real
temperature reading as soon as the Pi is wired up.

New top-level folder: fusion_iot/

1. **iot_base/** — Odoo S.A. iot_base module, copied from
   RePackaged-Odoo verbatim. LGPL-3 upstream, no changes needed.

2. **iot/** — Odoo S.A. iot module, repackaged:
   - `models/update.py` neutralised (removed the publisher_warranty
     IoT-Box-counting report that phones home to odoo.com for
     enterprise licence enforcement)
   - `iot_handlers/lib/load_worldline_library.sh` deleted (proprietary
     Worldline payment lib fetch from download.odoo.com, not needed)
   - `wizard/add_iot_box.py._connect_iot_box_with_pairing_code` —
     upstream called odoo.com's iot-proxy to resolve pairing codes;
     replaced with a no-op. Pi-side iot_drivers proxy registers
     directly with this Odoo server instead.
   - Manifest rebranded with an explicit changelog preamble.

3. **fusion_plating_iot/** — new plating-specific wrapper:
   - `fp.tank.sensor` — maps an iot.device (or a direct-HTTP-ingest
     sensor) to a fusion.plating.tank + fusion.plating.bath.parameter.
     Supports DS18B20, PT100/1000, pH, conductivity, level. Per-sensor
     alert_min/max overrides.
   - `fp.tank.reading` — append-only time-series. On create, evaluates
     against sensor's alert range. On in-spec → out-of-spec TRANSITION,
     auto-raises a fusion.plating.quality.hold (once per excursion,
     no spam during sustained out-of-spec).
   - `POST /fp/iot/ingest` — shared-secret HTTP endpoint for sensors
     bypassing the Pi proxy. Token via X-FP-IOT-Token header OR body.
     Accepts single-reading or batch payloads.
   - Menu under Plating → Operations → Sensors & Readings.
   - Tank form inherits get a Sensors tab inline.

Deployed to entech. Verified end-to-end:
- Install: iot_base + iot + fusion_plating_iot all 'installed'
- Smoke test: in-spec → out-of-spec → hold raised (HOLD-0010);
  continued excursion → NO duplicate hold; back-in-spec → NEW
  excursion → NEW hold (HOLD-0011) ✓
- HTTP endpoint: correct token → 200 accepted; wrong token → 401;
  unknown device_serial → 404; batch payload → 200 accepted=N ✓

Phase B (when Raspberry Pi hardware arrives): DS18B20 iot_handler
driver for the Pi-side iot_drivers proxy + systemd service on
vanilla Raspberry Pi OS + first live reading from physical probe.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
gsinghpal
2026-04-19 10:46:45 -04:00
parent c118b7c6b5
commit 6e964c230f
419 changed files with 76449 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
fusion_iot/fusion_plating_iot/__init__.py Normal file
View File

@@ -0,0 +1,7 @@
# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
# Part of the Fusion Plating product family.
from . import models
from . import controllers

56
fusion_iot/fusion_plating_iot/__manifest__.py Normal file
View File

@@ -0,0 +1,56 @@
# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
# Part of the Fusion Plating product family.
{
'name': 'Fusion Plating — IoT Integration',
'version': '19.0.0.1.0',
'category': 'Manufacturing/Plating',
'summary': 'Wire physical tank sensors to Fusion Plating — live '
'temperature / chemistry readings with auto quality holds '
'on out-of-spec.',
'description': """
Fusion Plating — IoT Integration
================================
Bridges the generic `iot` module (IoT Box + device management) to
plating-specific models:
* ``fp.tank.sensor`` — maps an ``iot.device`` to a
``fusion.plating.tank`` (or a ``fusion.plating.bath``).
* ``fp.tank.reading`` — time-series log of every sensor reading.
* Auto-creates a ``fusion.plating.quality.hold`` when a reading
falls outside the tank/bath's target range (per
``fusion.plating.bath.parameter`` spec).
Supports both the Odoo-IoT proxy path (Pi running iot_drivers) AND
a direct HTTP ingest path (``/fp/iot/ingest``) for sensors that
skip the proxy and POST straight to Odoo with a shared secret.
Part of the Fusion Plating product family by Nexa Systems Inc.
""",
'author': 'Nexa Systems Inc.',
'website': 'https://www.nexasystems.ca',
'maintainer': 'Nexa Systems Inc.',
'support': 'support@nexasystems.ca',
'license': 'OPL-1',
'price': 0.00,
'currency': 'CAD',
'depends': [
'iot',
'fusion_plating',
'fusion_plating_quality',
],
'data': [
'security/ir.model.access.csv',
'data/ir_config_parameter_data.xml',
'views/fp_tank_sensor_views.xml',
'views/fp_tank_reading_views.xml',
'views/fusion_plating_tank_views.xml',
'views/fp_iot_menu.xml',
],
'installable': True,
'application': False,
'auto_install': False,
}

1
fusion_iot/fusion_plating_iot/controllers/__init__.py Normal file
View File

@@ -0,0 +1 @@
from . import fp_iot_ingest

143
fusion_iot/fusion_plating_iot/controllers/fp_iot_ingest.py Normal file
View File

@@ -0,0 +1,143 @@
# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
# Part of the Fusion Plating product family.
"""Direct-HTTP ingest endpoint for sensors that bypass the Odoo IoT proxy.
Authentication: shared secret header `X-FP-IOT-Token` compared to the
system parameter `fusion_plating_iot.ingest_token`. The Pi proxy (via
iot_drivers) uses Odoo's built-in websocket and doesn't need this path.
Payload (JSON):
{
"device_serial": "28-abc123def456",
"value": 87.3,
"unit": "C", // informational, optional
"read_at": "2026-04-19T13:12:05Z" // optional; defaults to now
}
Or a batch form:
{
"token": "<shared secret>", // alternative to X-FP-IOT-Token
"readings": [
{"device_serial": "...", "value": ..., "read_at": "..."},
...
]
}
Returns 200 + `{ok: true, accepted: N}` on success, 401 on auth fail,
404 if any device_serial isn't mapped to a fp.tank.sensor.
"""
import hmac
import json
import logging
from datetime import datetime, timezone
from odoo import http
from odoo.http import request, Response
_logger = logging.getLogger(__name__)
def _parse_read_at(raw):
"""Best-effort ISO-8601 parse — fall back to 'now' on garbage input."""
from odoo.fields import Datetime as OdooDatetime
if not raw:
return OdooDatetime.now()
try:
# Accept both "2026-04-19T13:12:05Z" and "2026-04-19 13:12:05"
s = raw.replace('Z', '+00:00')
dt = datetime.fromisoformat(s)
# Strip tz to store naive UTC, which is what Odoo Datetime fields store
if dt.tzinfo is not None:
dt = dt.astimezone(timezone.utc).replace(tzinfo=None)
return dt
except Exception:
return OdooDatetime.now()
class FpIotIngestController(http.Controller):
@http.route('/fp/iot/ingest', type='http', auth='public',
methods=['POST'], csrf=False, save_session=False)
def ingest(self, **_kwargs):
"""Accept one-or-many sensor readings and land them in fp.tank.reading."""
# Pull the shared secret from config — configured at install via
# data/ir_config_parameter_data.xml, but admins can rotate it
# in Settings → Technical → System Parameters.
expected = request.env['ir.config_parameter'].sudo().get_param(
'fusion_plating_iot.ingest_token', ''
)
if not expected:
_logger.warning('fp.iot.ingest: token not configured — all requests rejected')
return Response(
json.dumps({'ok': False, 'error': 'token_not_configured'}),
status=503, content_type='application/json',
)
# Accept token via either header or payload body — some simple
# sensors can't easily set custom headers.
header_token = request.httprequest.headers.get('X-FP-IOT-Token', '')
raw = request.httprequest.get_data(as_text=True) or ''
try:
body = json.loads(raw) if raw else {}
except ValueError:
return Response(
json.dumps({'ok': False, 'error': 'invalid_json'}),
status=400, content_type='application/json',
)
body_token = body.get('token', '')
presented = header_token or body_token
if not hmac.compare_digest(str(presented), str(expected)):
return Response(
json.dumps({'ok': False, 'error': 'unauthorised'}),
status=401, content_type='application/json',
)
# Normalise payload to a list of readings.
readings = body.get('readings')
if readings is None:
# Single-reading shortcut
if 'device_serial' in body and 'value' in body:
readings = [body]
else:
return Response(
json.dumps({'ok': False, 'error': 'no_readings'}),
status=400, content_type='application/json',
)
Sensor = request.env['fp.tank.sensor'].sudo()
Reading = request.env['fp.tank.reading'].sudo()
accepted = 0
unknown_serials = []
for r in readings:
serial = (r.get('device_serial') or '').strip()
if not serial:
continue
sensor = Sensor.search([('device_serial', '=', serial)], limit=1)
if not sensor:
unknown_serials.append(serial)
continue
try:
value = float(r.get('value'))
except (TypeError, ValueError):
continue
Reading.create({
'sensor_id': sensor.id,
'value': value,
'reading_at': _parse_read_at(r.get('read_at')),
'source': 'http_ingest',
})
accepted += 1
status = 200 if accepted else (404 if unknown_serials else 400)
payload = {
'ok': accepted > 0,
'accepted': accepted,
}
if unknown_serials:
payload['unknown_serials'] = unknown_serials
return Response(
json.dumps(payload),
status=status, content_type='application/json',
)

16
fusion_iot/fusion_plating_iot/data/ir_config_parameter_data.xml Normal file
View File

@@ -0,0 +1,16 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright 2026 Nexa Systems Inc.
License OPL-1
Seed the shared-secret token for /fp/iot/ingest. Admins MUST rotate
this after install via Settings → Technical → System Parameters.
-->
<odoo noupdate="1">
<record id="fp_iot_ingest_token" model="ir.config_parameter">
<field name="key">fusion_plating_iot.ingest_token</field>
<field name="value">CHANGE-ME-AFTER-INSTALL</field>
</record>
</odoo>

4
fusion_iot/fusion_plating_iot/models/__init__.py Normal file
View File

@@ -0,0 +1,4 @@
# -*- coding: utf-8 -*-
from . import fp_tank_sensor
from . import fp_tank_reading
from . import fusion_plating_tank

189
fusion_iot/fusion_plating_iot/models/fp_tank_reading.py Normal file
View File

@@ -0,0 +1,189 @@
# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
# Part of the Fusion Plating product family.
"""Time-series of sensor readings.
Every POST to /fp/iot/ingest (or every broadcast from the iot proxy)
lands as a new row here. Kept intentionally append-only — we never
update or delete readings, which makes this the compliance log for
bath-temperature history.
Auto-creates a fusion.plating.quality.hold when a reading falls
outside the sensor's alert range AND the sensor has
`alert_on_out_of_spec` enabled. The hold is created once per
excursion (we don't spam a new hold for every reading during a
sustained excursion) — tracked via the sensor's most-recent
`last_reading_in_spec` flag.
"""
import logging
from odoo import api, fields, models
_logger = logging.getLogger(__name__)
class FpTankReading(models.Model):
_name = 'fp.tank.reading'
_description = 'Fusion Plating — Tank Sensor Reading'
_order = 'reading_at desc, id desc'
_rec_name = 'display_name'
sensor_id = fields.Many2one(
'fp.tank.sensor', string='Sensor', required=True,
ondelete='cascade', index=True,
)
# Denormalised for fast list views + kpi queries — auto-filled at
# create time from sensor_id. Indexed for historical trending.
tank_id = fields.Many2one(
'fusion.plating.tank', string='Tank',
related='sensor_id.tank_id', store=True, index=True,
)
bath_id = fields.Many2one(
'fusion.plating.bath', string='Bath',
related='sensor_id.bath_id', store=True,
)
parameter_id = fields.Many2one(
'fusion.plating.bath.parameter', string='Parameter',
related='sensor_id.parameter_id', store=True,
)
reading_at = fields.Datetime(
string='Read At', required=True,
default=fields.Datetime.now, index=True,
)
value = fields.Float(
string='Value', required=True, digits=(12, 4),
help='Numeric reading in the parameter\'s native unit (°C, pH, '
'µS/cm, etc.).',
)
unit = fields.Char(
string='Unit', related='parameter_id.uom', store=True,
)
source = fields.Selection(
[
('iot_proxy', 'IoT Proxy (Pi)'),
('http_ingest', 'HTTP Ingest (direct)'),
('manual', 'Manual Entry'),
],
string='Source', default='http_ingest', required=True,
)
in_spec = fields.Boolean(
string='In Spec', readonly=True,
help='Whether this reading fell within the sensor\'s alert range.',
)
hold_id = fields.Many2one(
'fusion.plating.quality.hold', string='Resulting Hold',
ondelete='set null', readonly=True,
help='The quality hold auto-created by this reading, if any. '
'Only the FIRST out-of-spec reading in an excursion creates '
'a hold; subsequent readings during the same excursion do '
'not duplicate.',
)
display_name = fields.Char(
string='Display', compute='_compute_display_name', store=True,
)
@api.depends('sensor_id', 'value', 'reading_at')
def _compute_display_name(self):
for r in self:
sensor = r.sensor_id.name or 'sensor'
at = fields.Datetime.to_string(r.reading_at) if r.reading_at else ''
unit = r.unit or ''
r.display_name = f'{sensor} — {r.value:.2f} {unit} @ {at}'
# ------------------------------------------------------------------
# Create hook — evaluate against spec + raise a quality hold if we
# just crossed INTO an out-of-spec state.
# ------------------------------------------------------------------
@api.model_create_multi
def create(self, vals_list):
records = super().create(vals_list)
for rec in records:
try:
rec._evaluate_spec()
except Exception:
# Never let alert-logic break the ingest path — the
# reading itself is what matters for compliance. Log
# and carry on.
_logger.exception(
'fp.tank.reading alert eval failed for reading %s', rec.id,
)
return records
def _evaluate_spec(self):
"""Set `in_spec`, update sensor cache, raise hold if this reading
is the first out-of-spec reading of a new excursion.
"""
self.ensure_one()
sensor = self.sensor_id
lo, hi = sensor._get_alert_range()
# Zero-bounded checks: a 0 value means "no bound defined"
ok_lo = (lo == 0.0) or (self.value >= lo)
ok_hi = (hi == 0.0) or (self.value <= hi)
in_spec = ok_lo and ok_hi
self.in_spec = in_spec
# Track excursion transitions on the sensor so we only fire ONE
# hold per out-of-spec episode, not one per reading.
previously_in_spec = sensor.last_reading_in_spec
sensor.sudo().write({
'last_reading_value': self.value,
'last_reading_at': self.reading_at,
'last_reading_in_spec': in_spec,
})
# Crossed from in-spec → out-of-spec on this reading
newly_excursion = (previously_in_spec and not in_spec)
first_reading_and_bad = (sensor.reading_count == 1 and not in_spec)
if (newly_excursion or first_reading_and_bad) and sensor.alert_on_out_of_spec:
self._raise_quality_hold()
def _raise_quality_hold(self):
"""Create a quality hold describing the out-of-spec reading."""
self.ensure_one()
Hold = self.env.get('fusion.plating.quality.hold')
if Hold is None:
return # quality module not installed
sensor = self.sensor_id
lo, hi = sensor._get_alert_range()
parts = [
f'Sensor {sensor.name!r} reading {self.value:.2f} '
f'{self.unit or ""} is out of spec.',
f'Target range: {lo:.2f} .. {hi:.2f}.',
]
if sensor.tank_id:
parts.append(f'Tank: {sensor.tank_id.name}.')
if sensor.bath_id:
parts.append(f'Bath: {sensor.bath_id.name}.')
description = ' '.join(parts)
hold_vals = {
'hold_reason': 'out_of_spec',
'description': description,
'qty_on_hold': 1,
# state defaults to 'on_hold' — leave it
}
# Attach facility + work-centre context if the tank has them,
# so the hold is actionable from the shop floor (operator can
# navigate back to the tank from the hold record).
if sensor.tank_id:
if 'facility_id' in Hold._fields:
tank_facility = getattr(sensor.tank_id, 'facility_id', None)
if tank_facility:
hold_vals['facility_id'] = tank_facility.id
if 'part_ref' in Hold._fields:
hold_vals['part_ref'] = f'Tank {sensor.tank_id.name} bath'
try:
hold = Hold.sudo().create(hold_vals)
self.hold_id = hold.id
_logger.info(
'fp.tank.reading %s triggered quality hold %s (%.2f %s out of %.2f..%.2f)',
self.id, hold.id, self.value, self.unit or '', lo, hi,
)
except Exception:
_logger.exception(
'Could not create quality hold for reading %s', self.id,
)

151
fusion_iot/fusion_plating_iot/models/fp_tank_sensor.py Normal file
View File

@@ -0,0 +1,151 @@
# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
# Part of the Fusion Plating product family.
"""Sensor → tank mapping.
One physical sensor (a DS18B20 probe, a MAX31865 RTD, or any future
device registered via the iot_drivers proxy) is mapped to exactly one
tank or bath and measures ONE bath parameter (temperature, pH,
conductivity, etc.).
The same tank can carry multiple sensors — e.g. a temp probe and a pH
probe. Each is its own fp.tank.sensor row.
"""
from odoo import api, fields, models
class FpTankSensor(models.Model):
_name = 'fp.tank.sensor'
_description = 'Fusion Plating — Tank Sensor'
_order = 'tank_id, parameter_id'
name = fields.Char(
string='Sensor Name', required=True,
help='Human label (e.g. "Tank 3 — ENP temp").',
)
active = fields.Boolean(default=True)
# ------------------------------------------------------------------
# Physical device — either an Odoo iot.device (proxied through the Pi)
# OR a direct-ingest sensor (skipping the proxy, posting straight to
# /fp/iot/ingest with the shared secret + device_serial).
# ------------------------------------------------------------------
iot_device_id = fields.Many2one(
'iot.device', string='IoT Device', ondelete='set null',
help='The iot.device record as registered by the Pi proxy. '
'Leave empty for direct-HTTP-ingest sensors.',
)
device_serial = fields.Char(
string='Device Serial', index=True,
help='Hardware unique ID (e.g. DS18B20 1-Wire address '
'"28-abc123def456"). Used by /fp/iot/ingest to route '
'posted readings to the right sensor.',
)
device_kind = fields.Selection(
[
('ds18b20', 'DS18B20 temperature'),
('pt100', 'PT100 RTD temperature'),
('pt1000', 'PT1000 RTD temperature'),
('ph', 'pH probe'),
('conductivity','Conductivity probe'),
('level', 'Level sensor'),
('other', 'Other'),
],
string='Sensor Type', default='ds18b20', required=True,
)
# ------------------------------------------------------------------
# Where this sensor lives + what it measures
# ------------------------------------------------------------------
tank_id = fields.Many2one(
'fusion.plating.tank', string='Tank', ondelete='cascade',
)
bath_id = fields.Many2one(
'fusion.plating.bath', string='Bath',
help='Optional — if the sensor is bound to a specific bath '
'chemistry rather than a physical tank.',
)
parameter_id = fields.Many2one(
'fusion.plating.bath.parameter', string='Parameter Measured',
required=True,
help='Which bath parameter this sensor reports (temperature, pH, '
'etc.). Drives unit labelling + out-of-spec alerting against '
'the parameter\'s target_min / target_max.',
)
# ------------------------------------------------------------------
# Alerting behaviour
# ------------------------------------------------------------------
alert_on_out_of_spec = fields.Boolean(
string='Alert on Out-of-Spec', default=True,
help='If checked, a fusion.plating.quality.hold is auto-created '
'when a reading falls outside the parameter target range.',
)
alert_min_override = fields.Float(
string='Alert Min (override)', digits=(10, 4),
help='Optional override of the parameter\'s target_min for this '
'specific sensor. Leave 0 to inherit from bath.parameter.',
)
alert_max_override = fields.Float(
string='Alert Max (override)', digits=(10, 4),
help='Optional override of the parameter\'s target_max for this '
'specific sensor.',
)
# ------------------------------------------------------------------
# Cached latest-reading fields (for quick display in list views)
# ------------------------------------------------------------------
last_reading_value = fields.Float(
string='Latest Value', readonly=True, digits=(12, 4),
)
last_reading_at = fields.Datetime(string='Latest Reading', readonly=True)
last_reading_in_spec = fields.Boolean(
string='In Spec?', readonly=True,
help='Computed from the last reading vs alert_min/alert_max.',
)
reading_ids = fields.One2many(
'fp.tank.reading', 'sensor_id', string='Reading History',
)
reading_count = fields.Integer(
string='Readings', compute='_compute_reading_count',
)
_sql_constraints = [
('fp_tank_sensor_serial_uniq',
'unique(device_serial)',
'Each hardware serial can only be mapped to one sensor.'),
]
@api.depends('reading_ids')
def _compute_reading_count(self):
for rec in self:
rec.reading_count = len(rec.reading_ids)
# ------------------------------------------------------------------
# Resolve effective alert range — override wins, else bath.parameter
# ------------------------------------------------------------------
def _get_alert_range(self):
"""Return (min, max) floats. Zero means 'no bound'."""
self.ensure_one()
lo = self.alert_min_override or (
self.parameter_id.target_min if self.parameter_id else 0.0
)
hi = self.alert_max_override or (
self.parameter_id.target_max if self.parameter_id else 0.0
)
return (lo or 0.0, hi or 0.0)
def action_view_readings(self):
self.ensure_one()
return {
'type': 'ir.actions.act_window',
'name': f'Readings — {self.name}',
'res_model': 'fp.tank.reading',
'view_mode': 'list,form,graph',
'domain': [('sensor_id', '=', self.id)],
'context': {'default_sensor_id': self.id},
'target': 'current',
}

33
fusion_iot/fusion_plating_iot/models/fusion_plating_tank.py Normal file
View File

@@ -0,0 +1,33 @@
# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
"""Lightweight extension of fusion.plating.tank to surface its mapped
sensors + latest reading state inline on the tank form.
"""
from odoo import api, fields, models
class FusionPlatingTank(models.Model):
_inherit = 'fusion.plating.tank'
x_fc_sensor_ids = fields.One2many(
'fp.tank.sensor', 'tank_id', string='Sensors',
)
x_fc_sensor_count = fields.Integer(
string='Sensor Count', compute='_compute_sensor_stats',
)
x_fc_has_out_of_spec = fields.Boolean(
string='Any Sensor Out of Spec', compute='_compute_sensor_stats',
help='True if ANY mapped sensor\'s latest reading is out of spec.',
)
@api.depends('x_fc_sensor_ids.last_reading_in_spec',
'x_fc_sensor_ids.last_reading_at')
def _compute_sensor_stats(self):
for tank in self:
live = tank.x_fc_sensor_ids.filtered(lambda s: s.last_reading_at)
tank.x_fc_sensor_count = len(tank.x_fc_sensor_ids)
tank.x_fc_has_out_of_spec = any(
not s.last_reading_in_spec for s in live
)

7
fusion_iot/fusion_plating_iot/security/ir.model.access.csv Normal file
View File

@@ -0,0 +1,7 @@
id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
fp_tank_sensor_operator,fp.tank.sensor operator,model_fp_tank_sensor,fusion_plating.group_fusion_plating_operator,1,0,0,0
fp_tank_sensor_supervisor,fp.tank.sensor supervisor,model_fp_tank_sensor,fusion_plating.group_fusion_plating_supervisor,1,1,1,0
fp_tank_sensor_manager,fp.tank.sensor manager,model_fp_tank_sensor,fusion_plating.group_fusion_plating_manager,1,1,1,1
fp_tank_reading_operator,fp.tank.reading operator,model_fp_tank_reading,fusion_plating.group_fusion_plating_operator,1,0,1,0
fp_tank_reading_supervisor,fp.tank.reading supervisor,model_fp_tank_reading,fusion_plating.group_fusion_plating_supervisor,1,0,1,0
fp_tank_reading_manager,fp.tank.reading manager,model_fp_tank_reading,fusion_plating.group_fusion_plating_manager,1,1,1,1
1 id name model_id:id group_id:id perm_read perm_write perm_create perm_unlink
2 fp_tank_sensor_operator fp.tank.sensor operator model_fp_tank_sensor fusion_plating.group_fusion_plating_operator 1 0 0 0
3 fp_tank_sensor_supervisor fp.tank.sensor supervisor model_fp_tank_sensor fusion_plating.group_fusion_plating_supervisor 1 1 1 0
4 fp_tank_sensor_manager fp.tank.sensor manager model_fp_tank_sensor fusion_plating.group_fusion_plating_manager 1 1 1 1
5 fp_tank_reading_operator fp.tank.reading operator model_fp_tank_reading fusion_plating.group_fusion_plating_operator 1 0 1 0
6 fp_tank_reading_supervisor fp.tank.reading supervisor model_fp_tank_reading fusion_plating.group_fusion_plating_supervisor 1 0 1 0
7 fp_tank_reading_manager fp.tank.reading manager model_fp_tank_reading fusion_plating.group_fusion_plating_manager 1 1 1 1

29
fusion_iot/fusion_plating_iot/views/fp_iot_menu.xml Normal file
View File

@@ -0,0 +1,29 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright 2026 Nexa Systems Inc.
License OPL-1
Surface IoT sensors + readings under the existing Plating >
Operations menu. Not a top-level app — sensors are an extension
of bath/tank management, not a separate concern.
-->
<odoo>
<menuitem id="menu_fp_iot_root"
name="Sensors &amp; Readings"
parent="fusion_plating.menu_fp_operations"
sequence="55"/>
<menuitem id="menu_fp_tank_sensor"
name="Tank Sensors"
parent="menu_fp_iot_root"
action="action_fp_tank_sensor"
sequence="10"/>
<menuitem id="menu_fp_tank_reading"
name="Sensor Readings"
parent="menu_fp_iot_root"
action="action_fp_tank_reading"
sequence="20"/>
</odoo>

97
fusion_iot/fusion_plating_iot/views/fp_tank_reading_views.xml Normal file
View File

@@ -0,0 +1,97 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright 2026 Nexa Systems Inc.
License OPL-1 (Odoo Proprietary License v1.0)
-->
<odoo>
<record id="fp_tank_reading_list" model="ir.ui.view">
<field name="name">fp.tank.reading.list</field>
<field name="model">fp.tank.reading</field>
<field name="arch" type="xml">
<list string="Sensor Readings"
decoration-danger="not in_spec" default_order="reading_at desc">
<field name="reading_at"/>
<field name="sensor_id"/>
<field name="tank_id" optional="show"/>
<field name="parameter_id" optional="hide"/>
<field name="value"/>
<field name="unit"/>
<field name="in_spec" widget="boolean_toggle"/>
<field name="source" optional="hide"/>
<field name="hold_id" optional="show"/>
</list>
</field>
</record>
<record id="fp_tank_reading_form" model="ir.ui.view">
<field name="name">fp.tank.reading.form</field>
<field name="model">fp.tank.reading</field>
<field name="arch" type="xml">
<form string="Sensor Reading" create="false">
<sheet>
<group>
<group>
<field name="sensor_id"/>
<field name="tank_id" readonly="1"/>
<field name="parameter_id" readonly="1"/>
<field name="source" readonly="1"/>
</group>
<group>
<field name="reading_at"/>
<field name="value"/>
<field name="unit" readonly="1"/>
<field name="in_spec" readonly="1"/>
<field name="hold_id" readonly="1"/>
</group>
</group>
</sheet>
</form>
</field>
</record>
<record id="fp_tank_reading_graph" model="ir.ui.view">
<field name="name">fp.tank.reading.graph</field>
<field name="model">fp.tank.reading</field>
<field name="arch" type="xml">
<graph string="Readings Trend" type="line">
<field name="reading_at" interval="hour"/>
<field name="value" type="measure"/>
</graph>
</field>
</record>
<record id="fp_tank_reading_search" model="ir.ui.view">
<field name="name">fp.tank.reading.search</field>
<field name="model">fp.tank.reading</field>
<field name="arch" type="xml">
<search>
<field name="sensor_id"/>
<field name="tank_id"/>
<field name="parameter_id"/>
<filter name="out_of_spec" string="Out of Spec"
domain="[('in_spec', '=', False)]"/>
<filter name="today" string="Today"
domain="[('reading_at', '&gt;=', (context_today()).strftime('%Y-%m-%d'))]"/>
<filter name="last_24h" string="Last 24h"
domain="[('reading_at', '&gt;=', (datetime.datetime.now() - datetime.timedelta(hours=24)).strftime('%Y-%m-%d %H:%M:%S'))]"/>
<group>
<filter name="by_sensor" string="Sensor"
context="{'group_by': 'sensor_id'}"/>
<filter name="by_tank" string="Tank"
context="{'group_by': 'tank_id'}"/>
<filter name="by_day" string="Day"
context="{'group_by': 'reading_at:day'}"/>
</group>
</search>
</field>
</record>
<record id="action_fp_tank_reading" model="ir.actions.act_window">
<field name="name">Sensor Readings</field>
<field name="res_model">fp.tank.reading</field>
<field name="view_mode">list,graph,form</field>
<field name="search_view_id" ref="fp_tank_reading_search"/>
</record>
</odoo>

126
fusion_iot/fusion_plating_iot/views/fp_tank_sensor_views.xml Normal file
View File

@@ -0,0 +1,126 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright 2026 Nexa Systems Inc.
License OPL-1 (Odoo Proprietary License v1.0)
-->
<odoo>
<!-- ===== List ===== -->
<record id="fp_tank_sensor_list" model="ir.ui.view">
<field name="name">fp.tank.sensor.list</field>
<field name="model">fp.tank.sensor</field>
<field name="arch" type="xml">
<list string="Tank Sensors" decoration-danger="not last_reading_in_spec and last_reading_at"
decoration-muted="not active">
<field name="name"/>
<field name="device_kind"/>
<field name="tank_id"/>
<field name="bath_id" optional="show"/>
<field name="parameter_id"/>
<field name="device_serial" optional="show"/>
<field name="iot_device_id" optional="hide"/>
<field name="last_reading_value"/>
<field name="last_reading_at"/>
<field name="last_reading_in_spec" widget="boolean_toggle"/>
<field name="reading_count"/>
<field name="active" column_invisible="1"/>
</list>
</field>
</record>
<!-- ===== Form ===== -->
<record id="fp_tank_sensor_form" model="ir.ui.view">
<field name="name">fp.tank.sensor.form</field>
<field name="model">fp.tank.sensor</field>
<field name="arch" type="xml">
<form string="Tank Sensor">
<header/>
<sheet>
<div class="oe_button_box" name="button_box">
<button name="action_view_readings" type="object"
class="oe_stat_button" icon="fa-line-chart">
<field name="reading_count" widget="statinfo"
string="Readings"/>
</button>
</div>
<widget name="web_ribbon" title="In Spec"
invisible="not last_reading_in_spec or not last_reading_at"
bg_color="text-bg-success"/>
<widget name="web_ribbon" title="OUT OF SPEC"
invisible="last_reading_in_spec or not last_reading_at"
bg_color="text-bg-danger"/>
<div class="oe_title">
<h1><field name="name" placeholder="e.g. Tank 3 — ENP temp"/></h1>
</div>
<group>
<group string="Hardware">
<field name="device_kind"/>
<field name="device_serial" placeholder="28-abc123def456"/>
<field name="iot_device_id"
options="{'no_create': True}"
help="Optional — the iot.device auto-registered by the Pi proxy."/>
<field name="active"/>
</group>
<group string="Location">
<field name="tank_id" options="{'no_create': True}"/>
<field name="bath_id" options="{'no_create': True}"/>
<field name="parameter_id" options="{'no_create': True}"/>
</group>
</group>
<group string="Alerting">
<group>
<field name="alert_on_out_of_spec"/>
<field name="alert_min_override"
help="Leave 0 to inherit from the bath parameter's target_min."/>
<field name="alert_max_override"
help="Leave 0 to inherit from the bath parameter's target_max."/>
</group>
<group string="Most Recent Reading">
<field name="last_reading_value" readonly="1"/>
<field name="last_reading_at" readonly="1"/>
<field name="last_reading_in_spec" readonly="1" widget="boolean_toggle"/>
</group>
</group>
</sheet>
</form>
</field>
</record>
<!-- ===== Search ===== -->
<record id="fp_tank_sensor_search" model="ir.ui.view">
<field name="name">fp.tank.sensor.search</field>
<field name="model">fp.tank.sensor</field>
<field name="arch" type="xml">
<search>
<field name="name"/>
<field name="device_serial"/>
<field name="tank_id"/>
<field name="parameter_id"/>
<filter name="out_of_spec" string="Out of Spec"
domain="[('last_reading_in_spec', '=', False),
('last_reading_at', '!=', False)]"/>
<filter name="alerting_on" string="Alerting Enabled"
domain="[('alert_on_out_of_spec', '=', True)]"/>
<filter name="inactive" string="Archived"
domain="[('active', '=', False)]"/>
<group>
<filter name="by_tank" string="Tank"
context="{'group_by': 'tank_id'}"/>
<filter name="by_parameter" string="Parameter"
context="{'group_by': 'parameter_id'}"/>
<filter name="by_kind" string="Sensor Type"
context="{'group_by': 'device_kind'}"/>
</group>
</search>
</field>
</record>
<!-- ===== Action ===== -->
<record id="action_fp_tank_sensor" model="ir.actions.act_window">
<field name="name">Tank Sensors</field>
<field name="res_model">fp.tank.sensor</field>
<field name="view_mode">list,form</field>
<field name="search_view_id" ref="fp_tank_sensor_search"/>
</record>
</odoo>

39
fusion_iot/fusion_plating_iot/views/fusion_plating_tank_views.xml Normal file
View File

@@ -0,0 +1,39 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright 2026 Nexa Systems Inc.
License OPL-1
Surface IoT sensors inline on the existing fusion.plating.tank form
so the bath operator sees live sensor status in context, not in a
separate app.
-->
<odoo>
<record id="fusion_plating_tank_form_iot_inherit" model="ir.ui.view">
<field name="name">fusion.plating.tank.form.iot</field>
<field name="model">fusion.plating.tank</field>
<field name="inherit_id" ref="fusion_plating.view_fp_tank_form"/>
<field name="arch" type="xml">
<xpath expr="//sheet" position="inside">
<notebook>
<page string="Sensors" name="iot_sensors">
<field name="x_fc_sensor_ids" context="{'default_tank_id': id}">
<list editable="bottom"
decoration-danger="not last_reading_in_spec and last_reading_at">
<field name="name"/>
<field name="device_kind"/>
<field name="device_serial"/>
<field name="parameter_id"/>
<field name="last_reading_value"/>
<field name="last_reading_at" readonly="1"/>
<field name="last_reading_in_spec" widget="boolean_toggle"/>
<field name="alert_on_out_of_spec" widget="boolean_toggle"/>
</list>
</field>
</page>
</notebook>
</xpath>
</field>
</record>
</odoo>