Odoo 19 Shop Floor Module:
Real-Time Production Tracking for Operators

from odoo import models, fields, api


class MrpWorkcenter(models.Model):
    _inherit = 'mrp.workcenter'

    # ── Shop Floor Display Settings ──
    tablet_login_required = fields.Boolean(
        string='Require Operator Login',
        default=True,
        help='Force operators to scan their badge or enter PIN before starting work orders.',
    )
    display_priority = fields.Integer(
        string='Display Order',
        default=10,
        help='Controls the left-to-right order of work centers in the Shop Floor view.',
    )
    auto_time_tracking = fields.Boolean(
        string='Auto Time Tracking',
        default=True,
        help='Automatically start the timer when an operator begins a work order.',
    )
    allow_parallel_operations = fields.Boolean(
        string='Allow Parallel Operations',
        default=False,
        help='Allow operators to work on multiple work orders simultaneously at this center.',
    )
    kiosk_background_color = fields.Char(
        string='Kiosk Background Color',
        default='#1a1a2e',
        help='Hex color for the Shop Floor column header. Helps operators identify their station.',
    )

    # ── Capacity and OEE ──
    target_oee = fields.Float(
        string='Target OEE (%)',
        default=85.0,
        help='Overall Equipment Effectiveness target. Used in dashboard KPIs.',
    )
    planned_downtime_minutes = fields.Float(
        string='Planned Downtime (min/shift)',
        default=30.0,
        help='Scheduled breaks, changeovers, maintenance per 8-hour shift.',
    )

    @api.depends('order_ids', 'order_ids.duration_expected', 'order_ids.duration')
    def _compute_current_oee(self):
        """Compute real-time OEE for dashboard display."""
        for wc in self:
            completed = wc.order_ids.filtered(
                lambda o: o.state == 'done'
                and o.date_finished
                and o.date_finished >= fields.Datetime.now().replace(hour=0, minute=0, second=0)
            )
            if completed:
                expected = sum(completed.mapped('duration_expected'))
                actual = sum(completed.mapped('duration'))
                wc.current_oee = (expected / actual * 100) if actual > 0 else 0
            else:
                wc.current_oee = 0.0

    current_oee = fields.Float(
        compute='_compute_current_oee',
        string='Current OEE (%)',
    )

from odoo import models, fields, api
from odoo.tools import float_round


class MrpWorkcenterProductivity(models.Model):
    _inherit = 'mrp.workcenter.productivity'

    operator_id = fields.Many2one(
        'hr.employee',
        string='Operator',
        help='Employee who performed this work order step.',
    )
    labor_cost = fields.Float(
        compute='_compute_labor_cost',
        string='Labor Cost',
        store=True,
        help='Computed from operator hourly rate × actual duration.',
    )

    @api.depends('duration', 'operator_id', 'operator_id.hourly_cost')
    def _compute_labor_cost(self):
        for record in self:
            if record.operator_id and record.duration:
                hours = record.duration / 60.0
                rate = record.operator_id.hourly_cost or record.workcenter_id.costs_hour
                record.labor_cost = float_round(hours * rate, precision_digits=2)
            else:
                record.labor_cost = 0.0


class MrpWorkorder(models.Model):
    _inherit = 'mrp.workorder'

    total_labor_cost = fields.Float(
        compute='_compute_total_labor_cost',
        string='Total Labor Cost',
        store=True,
    )
    efficiency_ratio = fields.Float(
        compute='_compute_efficiency_ratio',
        string='Efficiency (%)',
        help='Expected duration / Actual duration × 100',
    )

    @api.depends('time_ids.labor_cost')
    def _compute_total_labor_cost(self):
        for wo in self:
            wo.total_labor_cost = sum(wo.time_ids.mapped('labor_cost'))

    @api.depends('duration_expected', 'duration')
    def _compute_efficiency_ratio(self):
        for wo in self:
            if wo.duration > 0:
                wo.efficiency_ratio = float_round(
                    (wo.duration_expected / wo.duration) * 100,
                    precision_digits=1,
                )
            else:
                wo.efficiency_ratio = 0.0

from odoo import models, api, _
from odoo.exceptions import UserError


class MrpWorkorder(models.Model):
    _inherit = 'mrp.workorder'

    def action_scan_component_barcode(self, barcode):
        """Process a scanned barcode during a work order.

        Handles three barcode types:
        1. Product barcode → confirms correct component
        2. Lot/Serial barcode → assigns traceability
        3. Employee barcode → logs operator identity
        """
        self.ensure_one()

        # Check if it's an employee badge scan
        employee = self.env['hr.employee'].search([('barcode', '=', barcode)], limit=1)
        if employee:
            return self._handle_operator_scan(employee)

        # Check if it's a lot/serial number
        lot = self.env['stock.lot'].search([('name', '=', barcode)], limit=1)
        if lot:
            return self._handle_lot_scan(lot)

        # Check if it's a product barcode
        product = self.env['product.product'].search([('barcode', '=', barcode)], limit=1)
        if product:
            return self._handle_component_scan(product)

        raise UserError(_('Barcode "%s" not recognized. Scan a component, lot number, or employee badge.', barcode))

    def _handle_component_scan(self, product):
        """Verify scanned component matches expected BOM line."""
        expected_moves = self.move_raw_ids.filtered(
            lambda m: m.product_id == product and m.state not in ('done', 'cancel')
        )
        if not expected_moves:
            raise UserError(_(
                'Product "%s" is not a required component for this work order. '
                'Expected components: %s',
                product.display_name,
                ', '.join(self.move_raw_ids.mapped('product_id.display_name')),
            ))
        # Mark component as scanned/verified
        expected_moves[0].write({'is_scanned': True})
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {
                'title': _('Component Verified'),
                'message': _('%s scanned successfully.', product.display_name),
                'type': 'success',
                'sticky': False,
            },
        }

    def _handle_lot_scan(self, lot):
        """Assign scanned lot to the current work order's output."""
        if lot.product_id != self.product_id:
            raise UserError(_(
                'Lot "%s" belongs to product "%s", but this work order produces "%s".',
                lot.name, lot.product_id.display_name, self.product_id.display_name,
            ))
        self.finished_lot_id = lot
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {
                'title': _('Lot Assigned'),
                'message': _('Lot %s assigned to output.', lot.name),
                'type': 'success',
                'sticky': False,
            },
        }

    def _handle_operator_scan(self, employee):
        """Log operator identity for the current work order."""
        self.write({'employee_id': employee.id})
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {
                'title': _('Operator Logged'),
                'message': _('Welcome, %s.', employee.name),
                'type': 'info',
                'sticky': False,
            },
        }