Odoo-Modules/fusion_plating/fusion_plating/models/fp_operator_certification.py

# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
# Part of the Fusion Plating product family.

from odoo import api, fields, models, _


class FpOperatorCertification(models.Model):
    """A signed-off training record that certifies an operator on a
    specific process type.

    Used to gate shop-floor work orders: an operator cannot start a
    plating WO unless they hold a current (non-expired) certification
    for that process.
    """
    _name = 'fp.operator.certification'
    _description = 'Fusion Plating — Operator Certification'
    _inherit = ['mail.thread', 'mail.activity.mixin']
    _order = 'employee_id, process_type_id'

    name = fields.Char(
        string='Certification Ref',
        compute='_compute_name', store=True,
    )
    employee_id = fields.Many2one(
        'hr.employee', string='Operator', required=True,
        ondelete='cascade', tracking=True,
    )
    process_type_id = fields.Many2one(
        'fusion.plating.process.type', string='Process Type',
        required=True, ondelete='restrict', tracking=True,
    )
    issued_date = fields.Date(
        string='Issued', default=fields.Date.today, required=True,
    )
    expires_date = fields.Date(
        string='Expires',
        help='Blank = no expiry. Set a date for re-certification tracking.',
    )
    issued_by_id = fields.Many2one(
        'res.users', string='Certified By', default=lambda self: self.env.user,
    )
    training_record_attachment_id = fields.Many2one(
        'ir.attachment', string='Training Record',
    )
    notes = fields.Text(string='Notes')
    revoked = fields.Boolean(string='Revoked', tracking=True)
    revoked_reason = fields.Text(string='Revoked Reason')
    state = fields.Selection(
        [('active', 'Active'),
         ('expired', 'Expired'),
         ('revoked', 'Revoked')],
        string='Status',
        compute='_compute_state', store=True, tracking=True,
        # NOT readonly=False — this is purely derived from revoked + expires_date
        # so the nightly recompute never fights with manual edits.
    )

    @api.depends('employee_id', 'process_type_id')
    def _compute_name(self):
        for rec in self:
            if rec.employee_id and rec.process_type_id:
                rec.name = f'{rec.employee_id.name} / {rec.process_type_id.name}'
            else:
                rec.name = ''

    @api.depends('expires_date', 'revoked')
    def _compute_state(self):
        today = fields.Date.today()
        for rec in self:
            if rec.revoked:
                rec.state = 'revoked'
            elif rec.expires_date and rec.expires_date < today:
                rec.state = 'expired'
            else:
                rec.state = 'active'

    @api.constrains('employee_id', 'process_type_id', 'revoked', 'expires_date')
    def _check_single_active(self):
        """At most one active certification per (employee, process_type)."""
        today = fields.Date.today()
        for rec in self:
            if rec.revoked:
                continue
            if rec.expires_date and rec.expires_date < today:
                continue
            # This record is active — look for another active sibling
            dupes = self.search_count([
                ('id', '!=', rec.id),
                ('employee_id', '=', rec.employee_id.id),
                ('process_type_id', '=', rec.process_type_id.id),
                ('revoked', '=', False),
                '|', ('expires_date', '=', False),
                     ('expires_date', '>=', today),
            ])
            if dupes:
                from odoo.exceptions import ValidationError
                raise ValidationError(_(
                    'Operator %s already has an active certification for "%s". '
                    'Revoke or expire the existing one before adding another.'
                ) % (rec.employee_id.name, rec.process_type_id.name))

    def action_revoke(self):
        for rec in self:
            rec.revoked = True
            rec.message_post(body=_('Certification revoked.'))

    @api.model
    def has_active_cert(self, employee_id, process_type_id):
        """Utility — True if this employee holds a current certification.

        Checks revoked + expires_date directly instead of the computed
        `state` column, so even a certification that expired yesterday
        is caught immediately (no wait for nightly recompute).
        """
        if not employee_id or not process_type_id:
            return False
        today = fields.Date.today()
        return bool(self.search_count([
            ('employee_id', '=', employee_id),
            ('process_type_id', '=', process_type_id),
            ('revoked', '=', False),
            '|', ('expires_date', '=', False),
                 ('expires_date', '>=', today),
        ]))


class HrEmployee(models.Model):
    _inherit = 'hr.employee'

    x_fc_certification_ids = fields.One2many(
        'fp.operator.certification', 'employee_id',
        string='Plating Certifications',
    )
    x_fc_certified_process_ids = fields.Many2many(
        'fusion.plating.process.type', compute='_compute_certified_processes',
        string='Certified Processes',
    )

    @api.depends('x_fc_certification_ids.state', 'x_fc_certification_ids.process_type_id')
    def _compute_certified_processes(self):
        for emp in self:
            active = emp.x_fc_certification_ids.filtered(lambda c: c.state == 'active')
            emp.x_fc_certified_process_ids = active.mapped('process_type_id')