299 lines
12 KiB
Python
299 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright 2026 Nexa Systems Inc.
|
|
# License OPL-1 (Odoo Proprietary License v1.0)
|
|
# Part of the Fusion Plating product family.
|
|
#
|
|
# Sub 8 — Racking-time inspection record. Captures the per-part
|
|
# inspection the racking crew performs when they open the customer's
|
|
# boxes (which is DIFFERENT from receiving — receiving is box count
|
|
# only). One record per MO.
|
|
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
from odoo import _, api, fields, models
|
|
from odoo.exceptions import UserError, ValidationError
|
|
|
|
|
|
class FpRackingInspection(models.Model):
|
|
_name = 'fp.racking.inspection'
|
|
_description = 'Racking-time Inspection'
|
|
_inherit = ['mail.thread', 'mail.activity.mixin']
|
|
_order = 'create_date desc, id desc'
|
|
|
|
name = fields.Char(compute='_compute_name', store=True)
|
|
# Phase 6 (Sub 11) — production_id retired (MRP module gone).
|
|
# x_fc_job_id is the canonical link. Declared here so this module's
|
|
# views can reference it at view-load time; fusion_plating_jobs adds
|
|
# the constraints + compute overrides via inheritance.
|
|
x_fc_job_id = fields.Many2one(
|
|
'fp.job', string='Plating Job',
|
|
index=True, ondelete='cascade',
|
|
)
|
|
sale_order_id = fields.Many2one(
|
|
'sale.order',
|
|
string='Sale Order',
|
|
compute='_compute_sale_order',
|
|
store=True,
|
|
)
|
|
partner_id = fields.Many2one(
|
|
'res.partner',
|
|
string='Customer',
|
|
compute='_compute_sale_order',
|
|
store=True,
|
|
)
|
|
receiving_id = fields.Many2one(
|
|
'fp.receiving',
|
|
string='Source Receiving',
|
|
compute='_compute_receiving_id',
|
|
store=True,
|
|
help='The receiving record whose boxes feed this inspection.',
|
|
)
|
|
state = fields.Selection(
|
|
[('draft', 'Draft'),
|
|
('inspecting', 'Inspecting'),
|
|
('done', 'Done'),
|
|
('discrepancy_flagged', 'Discrepancy Flagged')],
|
|
default='draft',
|
|
required=True,
|
|
tracking=True,
|
|
)
|
|
inspector_id = fields.Many2one(
|
|
'res.users',
|
|
string='Inspector',
|
|
readonly=True,
|
|
copy=False,
|
|
tracking=True,
|
|
)
|
|
inspection_started = fields.Datetime(readonly=True, copy=False)
|
|
inspection_completed = fields.Datetime(readonly=True, copy=False)
|
|
line_ids = fields.One2many(
|
|
'fp.racking.inspection.line',
|
|
'inspection_id',
|
|
copy=True,
|
|
)
|
|
notes = fields.Text()
|
|
company_id = fields.Many2one(
|
|
'res.company',
|
|
required=True,
|
|
default=lambda s: s.env.company,
|
|
)
|
|
|
|
line_count = fields.Integer(compute='_compute_line_stats')
|
|
ok_count = fields.Integer(compute='_compute_line_stats')
|
|
flagged_count = fields.Integer(compute='_compute_line_stats')
|
|
has_variance = fields.Boolean(compute='_compute_line_stats')
|
|
|
|
# Phase 6 (Sub 11) — production_id retired (MRP module gone). The
|
|
# uniqueness constraint that used to ride on production_id is now
|
|
# enforced via @api.constrains on x_fc_job_id (added by
|
|
# fusion_plating_jobs).
|
|
|
|
# ---- Computes ------------------------------------------------------------
|
|
|
|
@api.depends('partner_id.name')
|
|
def _compute_name(self):
|
|
# Override in fusion_plating_jobs reads x_fc_job_id; this base
|
|
# version is the bare-bones fallback.
|
|
for rec in self:
|
|
rec.name = _('Racking Inspection')
|
|
|
|
@api.depends('partner_id')
|
|
def _compute_sale_order(self):
|
|
# Override in fusion_plating_jobs walks x_fc_job_id.sale_order_id;
|
|
# this base version is a fallback.
|
|
for rec in self:
|
|
rec.sale_order_id = rec.sale_order_id or False
|
|
rec.partner_id = rec.partner_id or False
|
|
|
|
@api.depends('sale_order_id')
|
|
def _compute_receiving_id(self):
|
|
Receiving = self.env['fp.receiving']
|
|
for rec in self:
|
|
rec.receiving_id = (
|
|
Receiving.search(
|
|
[('sale_order_id', '=', rec.sale_order_id.id)], limit=1,
|
|
)
|
|
if rec.sale_order_id else False
|
|
)
|
|
|
|
@api.depends('line_ids.condition', 'line_ids.qty_variance')
|
|
def _compute_line_stats(self):
|
|
for rec in self:
|
|
rec.line_count = len(rec.line_ids)
|
|
rec.ok_count = len(rec.line_ids.filtered(
|
|
lambda l: l.condition == 'ok' and l.qty_variance == 0
|
|
))
|
|
rec.flagged_count = len(rec.line_ids.filtered(
|
|
lambda l: l.condition != 'ok' or l.qty_variance != 0
|
|
))
|
|
rec.has_variance = bool(rec.flagged_count)
|
|
|
|
# ---- Actions -------------------------------------------------------------
|
|
|
|
def action_start(self):
|
|
"""Racker opens the boxes and begins inspecting."""
|
|
for rec in self:
|
|
if rec.state != 'draft':
|
|
raise UserError(_('Can only start a Draft inspection.'))
|
|
rec.write({
|
|
'state': 'inspecting',
|
|
'inspector_id': self.env.user.id,
|
|
'inspection_started': fields.Datetime.now(),
|
|
})
|
|
rec.message_post(body=_('Inspection started by %s.') % self.env.user.name)
|
|
|
|
def action_complete(self):
|
|
"""Racker is satisfied with the inspection. Advance to Done."""
|
|
for rec in self:
|
|
if rec.state != 'inspecting':
|
|
raise UserError(_('Can only complete an Inspecting record.'))
|
|
new_state = 'discrepancy_flagged' if rec.flagged_count else 'done'
|
|
rec.write({
|
|
'state': new_state,
|
|
'inspection_completed': fields.Datetime.now(),
|
|
})
|
|
if new_state == 'discrepancy_flagged':
|
|
# 2026-04-28 — Activity must land on a real user.
|
|
# Resolve the assignee in priority order:
|
|
# 1. The job's plating manager (if set on fp.job)
|
|
# 2. The inspector who just flagged it
|
|
# 3. The current user (env.uid fallback)
|
|
# `activity_schedule` defaults to env.uid only when the
|
|
# record has a `user_id` field; fp.racking.inspection
|
|
# has `inspector_id` but not `user_id`, so we'd land on
|
|
# False if we let it default. Explicit assignment is
|
|
# the only safe path.
|
|
assignee = False
|
|
if (rec.x_fc_job_id and 'manager_id' in rec.x_fc_job_id._fields
|
|
and rec.x_fc_job_id.manager_id):
|
|
assignee = rec.x_fc_job_id.manager_id.id
|
|
elif rec.inspector_id:
|
|
assignee = rec.inspector_id.id
|
|
else:
|
|
assignee = self.env.uid
|
|
# 3-day deadline so it surfaces in "Overdue" dashboards
|
|
# if not addressed before plating starts.
|
|
deadline = fields.Date.today() + relativedelta(days=3)
|
|
rec.activity_schedule(
|
|
'mail.mail_activity_data_todo',
|
|
summary=_('Racking discrepancy on %s') % (
|
|
rec.name or ''
|
|
),
|
|
note=_(
|
|
'%(n)d line(s) flagged — review before starting '
|
|
'the first plating WO.'
|
|
) % {'n': rec.flagged_count},
|
|
user_id=assignee,
|
|
date_deadline=deadline,
|
|
)
|
|
rec.message_post(body=_(
|
|
'Inspection completed — %(ok)d ok / %(flag)d flagged.'
|
|
) % {'ok': rec.ok_count, 'flag': rec.flagged_count})
|
|
|
|
def action_reopen(self):
|
|
"""Manager only — reopen a done inspection."""
|
|
if not self.env.user.has_group(
|
|
'fusion_plating.group_fusion_plating_manager'):
|
|
raise UserError(_('Only a Plating Manager can reopen a completed '
|
|
'racking inspection.'))
|
|
for rec in self:
|
|
rec.write({
|
|
'state': 'inspecting',
|
|
'inspection_completed': False,
|
|
})
|
|
rec.message_post(body=_('Reopened by %s.') % self.env.user.name)
|
|
|
|
|
|
class FpRackingInspectionLine(models.Model):
|
|
_name = 'fp.racking.inspection.line'
|
|
_description = 'Racking Inspection Line'
|
|
_order = 'inspection_id, sequence, id'
|
|
|
|
inspection_id = fields.Many2one(
|
|
'fp.racking.inspection',
|
|
required=True,
|
|
ondelete='cascade',
|
|
)
|
|
sequence = fields.Integer(default=10)
|
|
part_catalog_id = fields.Many2one(
|
|
'fp.part.catalog', string='Part',
|
|
)
|
|
part_number = fields.Char(
|
|
related='part_catalog_id.part_number', store=True,
|
|
)
|
|
part_revision = fields.Char(
|
|
related='part_catalog_id.revision', store=True,
|
|
)
|
|
qty_expected = fields.Integer(string='Expected Qty')
|
|
qty_found = fields.Integer(string='Counted Qty')
|
|
qty_variance = fields.Integer(
|
|
compute='_compute_qty_variance', store=True,
|
|
)
|
|
condition = fields.Selection(
|
|
[('ok', 'OK'),
|
|
('minor', 'Minor Issue'),
|
|
('major', 'Major Issue'),
|
|
('reject', 'Reject')],
|
|
default='ok',
|
|
required=True,
|
|
)
|
|
notes = fields.Char(string='Notes')
|
|
|
|
# 2026-04-28 — photos on a line (compliance need: damage evidence,
|
|
# box-by-box condition record). Many2many to ir.attachment so an
|
|
# operator can shoot multiple angles per box from the floor without
|
|
# leaving the form. Cascade-deleted with the line.
|
|
photo_ids = fields.Many2many(
|
|
'ir.attachment',
|
|
relation='fp_racking_insp_line_photo_rel',
|
|
column1='line_id',
|
|
column2='attachment_id',
|
|
string='Photos',
|
|
domain="[('mimetype', 'ilike', 'image/')]",
|
|
help='Damage / condition photos for this box. Click + to upload '
|
|
'one or more from the camera roll. Cascades on delete.',
|
|
)
|
|
photo_count = fields.Integer(
|
|
string='# Photos',
|
|
compute='_compute_photo_count',
|
|
)
|
|
|
|
@api.depends('photo_ids')
|
|
def _compute_photo_count(self):
|
|
for rec in self:
|
|
rec.photo_count = len(rec.photo_ids)
|
|
|
|
@api.model_create_multi
|
|
def create(self, vals_list):
|
|
# Auto-populate part_catalog_id from the parent inspection's job
|
|
# when the operator added a line without picking a part. The
|
|
# job's SO carries the customer's part — pre-fill the line so
|
|
# the audit trail captures it without requiring extra clicks.
|
|
for vals in vals_list:
|
|
if not vals.get('part_catalog_id') and vals.get('inspection_id'):
|
|
ri = self.env['fp.racking.inspection'].browse(
|
|
vals['inspection_id'])
|
|
if ri.exists() and ri.x_fc_job_id:
|
|
so = ri.x_fc_job_id.sale_order_id
|
|
if so:
|
|
line = so.order_line.filtered(
|
|
lambda l: l.x_fc_part_catalog_id
|
|
)[:1]
|
|
if line:
|
|
vals['part_catalog_id'] = line.x_fc_part_catalog_id.id
|
|
return super().create(vals_list)
|
|
|
|
@api.depends('qty_expected', 'qty_found')
|
|
def _compute_qty_variance(self):
|
|
for rec in self:
|
|
rec.qty_variance = (rec.qty_found or 0) - (rec.qty_expected or 0)
|
|
|
|
@api.depends('part_catalog_id', 'part_number', 'qty_found', 'qty_expected')
|
|
def _compute_display_name(self):
|
|
for rec in self:
|
|
label = (rec.part_catalog_id.display_name
|
|
or rec.part_number
|
|
or 'Inspection Line')
|
|
qty = '%d/%d' % (rec.qty_found or 0, rec.qty_expected or 0)
|
|
rec.display_name = '%s (%s)' % (label, qty)
|