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

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

The x_fc_plating_role Selection field is a clean UX wrapper around the
seven plating-role groups. Owner-only Team page reads/writes this field
via drag-and-drop on a kanban grouped by role.
"""
from markupsafe import Markup

from odoo import _, api, fields, models


_FP_PLATING_ROLE_TO_GROUP_XMLID = {
    'technician':      'fusion_plating.group_fp_technician',
    'sales_rep':       'fusion_plating.group_fp_sales_rep',
    'shop_manager':    'fusion_plating.group_fp_shop_manager_v2',
    'sales_manager':   'fusion_plating.group_fp_sales_manager',
    'manager':         'fusion_plating.group_fp_manager',
    'quality_manager': 'fusion_plating.group_fp_quality_manager',
    'owner':           'fusion_plating.group_fp_owner',
}

# Highest precedence first — first match wins
_FP_ROLE_PRECEDENCE = (
    'owner', 'quality_manager', 'manager', 'sales_manager',
    'shop_manager', 'sales_rep', 'technician',
)


class ResUsers(models.Model):
    _inherit = 'res.users'

    # Allow non-admin users to write their OWN plating-related fields
    # from the standard User Preferences dialog. SELF_WRITEABLE_FIELDS is
    # a @property in Odoo 19 (not a class attribute) — must override via
    # @property + super(). See CLAUDE.md rule 13k.
    @property
    def SELF_WRITEABLE_FIELDS(self):
        return super().SELF_WRITEABLE_FIELDS + [
            'x_fc_plating_landing_action_id',  # personal landing-page override
            'x_fc_signature_image',            # "Plating Signature" used on reports
        ]

    @property
    def SELF_READABLE_FIELDS(self):
        return super().SELF_READABLE_FIELDS + [
            'x_fc_plating_landing_action_id',
            'x_fc_signature_image',
            'x_fc_plating_role',
            'x_fc_tablet_pin_set_date',
        ]

    x_fc_plating_role = fields.Selection(
        [
            ('no',              'No'),
            ('technician',      'Technician'),
            ('sales_rep',       'Sales Representative'),
            ('shop_manager',    'Shop Manager'),
            ('sales_manager',   'Sales Manager'),
            ('manager',         'Manager'),
            ('quality_manager', 'Quality Manager'),
            ('owner',           'Owner'),
        ],
        compute='_compute_plating_role',
        inverse='_inverse_plating_role',
        store=True,
        string='Fusion Plating Role',
        help='Highest plating role currently held by this user. Changing this '
             'field reassigns the user to the corresponding res.groups (clears '
             'old plating groups, adds new). Posts an audit chatter message.',
    )

    @api.depends('group_ids')
    def _compute_plating_role(self):
        # Resolve xmlids once
        role_to_group = {}
        for role, xmlid in _FP_PLATING_ROLE_TO_GROUP_XMLID.items():
            grp = self.env.ref(xmlid, raise_if_not_found=False)
            if grp:
                role_to_group[role] = grp
        for user in self:
            user.x_fc_plating_role = 'no'
            for candidate in _FP_ROLE_PRECEDENCE:
                grp = role_to_group.get(candidate)
                if grp and grp in user.group_ids:
                    user.x_fc_plating_role = candidate
                    break

    def _inverse_plating_role(self):
        # Resolve all plating-role group ids
        all_role_ids = []
        role_to_group = {}
        for role, xmlid in _FP_PLATING_ROLE_TO_GROUP_XMLID.items():
            grp = self.env.ref(xmlid, raise_if_not_found=False)
            if grp:
                role_to_group[role] = grp
                all_role_ids.append(grp.id)

        # I4 fix — capture old roles BEFORE the cache mutates by reading
        # the stored x_fc_plating_role column directly from PostgreSQL.
        # `user._origin.x_fc_plating_role` returns the IN-CACHE new value
        # (the assignment that triggered the inverse), not the prior DB
        # value, so the chatter audit displayed "X -> X" instead of the
        # actual old -> new transition.
        self.env.cr.execute(
            "SELECT id, x_fc_plating_role FROM res_users WHERE id IN %s",
            (tuple(self.ids),) if self.ids else ((0,),),
        )
        old_role_by_id = dict(self.env.cr.fetchall())

        for user in self:
            old_role = old_role_by_id.get(user.id) or 'unset'
            new_role = user.x_fc_plating_role
            if old_role == new_role:
                # No actual change — skip both the writes and the audit so
                # we don't spam chatter with "X -> X" rows.
                continue

            # Remove every plating-role group (additive-by-default Odoo
            # m2m write of (3, id) removes single rows)
            user.sudo().write({
                'group_ids': [(3, gid) for gid in all_role_ids]
            })

            # Add the chosen role (no-op for 'no')
            if new_role and new_role != 'no':
                target = role_to_group.get(new_role)
                if target:
                    user.sudo().write({
                        'group_ids': [(4, target.id)]
                    })

            # Post audit (Markup so role names render bold, not literal HTML)
            user.partner_id.message_post(
                body=Markup(_(
                    'Plating role changed: <b>%(old)s</b> -> <b>%(new)s</b> by %(actor)s'
                )) % {
                    'old': old_role,
                    'new': new_role or 'unset',
                    'actor': self.env.user.name,
                },
                message_type='notification',
            )