forked from Mapan/odoo17e
577 lines
27 KiB
Python
577 lines
27 KiB
Python
# -*- coding: utf-8 -*-
|
||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||
from math import sqrt
|
||
from dateutil.relativedelta import relativedelta
|
||
from datetime import datetime
|
||
|
||
import random
|
||
|
||
from odoo import api, models, fields, _
|
||
from odoo.tools import DEFAULT_SERVER_DATETIME_FORMAT, float_round
|
||
from odoo.osv.expression import OR
|
||
|
||
|
||
class QualityPoint(models.Model):
|
||
_inherit = "quality.point"
|
||
|
||
failure_message = fields.Html('Failure Message')
|
||
failure_location_ids = fields.Many2many('stock.location', string="Failure Locations", domain="[('usage', '=', 'internal')]",
|
||
help="If a quality check fails, a location is chosen from this list for each failed quantity.")
|
||
measure_on = fields.Selection([
|
||
('operation', 'Operation'),
|
||
('product', 'Product'),
|
||
('move_line', 'Quantity')], string="Control per", default='product', required=True,
|
||
help="""Operation = One quality check is requested at the operation level.
|
||
Product = A quality check is requested per product.
|
||
Quantity = A quality check is requested for each new product quantity registered, with partial quantity checks also possible.""")
|
||
measure_frequency_type = fields.Selection([
|
||
('all', 'All'),
|
||
('random', 'Randomly'),
|
||
('periodical', 'Periodically')], string="Control Frequency",
|
||
default='all', required=True)
|
||
measure_frequency_value = fields.Float('Percentage') # TDE RENAME ?
|
||
measure_frequency_unit_value = fields.Integer('Frequency Unit Value') # TDE RENAME ?
|
||
measure_frequency_unit = fields.Selection([
|
||
('day', 'Days'),
|
||
('week', 'Weeks'),
|
||
('month', 'Months')], default="day") # TDE RENAME ?
|
||
is_lot_tested_fractionally = fields.Boolean(string="Lot Tested Fractionally", help="Determines if only a fraction of the lot should be tested",
|
||
compute="_compute_is_lot_tested_fractionally")
|
||
testing_percentage_within_lot = fields.Float(help="Defines the percentage within a lot that should be tested", default=100)
|
||
norm = fields.Float('Norm', digits='Quality Tests') # TDE RENAME ?
|
||
tolerance_min = fields.Float('Min Tolerance', digits='Quality Tests')
|
||
tolerance_max = fields.Float('Max Tolerance', digits='Quality Tests')
|
||
norm_unit = fields.Char('Norm Unit', default=lambda self: 'mm') # TDE RENAME ?
|
||
average = fields.Float(compute="_compute_standard_deviation_and_average")
|
||
standard_deviation = fields.Float(compute="_compute_standard_deviation_and_average")
|
||
|
||
@api.depends('testing_percentage_within_lot')
|
||
def _compute_is_lot_tested_fractionally(self):
|
||
for point in self:
|
||
point.is_lot_tested_fractionally = point.testing_percentage_within_lot < 100
|
||
|
||
def _compute_standard_deviation_and_average(self):
|
||
# The variance and mean are computed by the Welford’s method and used the Bessel's
|
||
# correction because are working on a sample.
|
||
for point in self:
|
||
if point.test_type != 'measure':
|
||
point.average = 0
|
||
point.standard_deviation = 0
|
||
continue
|
||
mean = 0.0
|
||
s = 0.0
|
||
n = 0
|
||
for check in point.check_ids.filtered(lambda x: x.quality_state != 'none'):
|
||
n += 1
|
||
delta = check.measure - mean
|
||
mean += delta / n
|
||
delta2 = check.measure - mean
|
||
s += delta * delta2
|
||
|
||
if n > 1:
|
||
point.average = mean
|
||
point.standard_deviation = sqrt( s / ( n - 1))
|
||
elif n == 1:
|
||
point.average = mean
|
||
point.standard_deviation = 0.0
|
||
else:
|
||
point.average = 0.0
|
||
point.standard_deviation = 0.0
|
||
|
||
@api.onchange('norm')
|
||
def onchange_norm(self):
|
||
if self.tolerance_max == 0.0:
|
||
self.tolerance_max = self.norm
|
||
|
||
def check_execute_now(self):
|
||
self.ensure_one()
|
||
if self.measure_frequency_type == 'all':
|
||
return True
|
||
elif self.measure_frequency_type == 'random':
|
||
return (random.random() < self.measure_frequency_value / 100.0)
|
||
elif self.measure_frequency_type == 'periodical':
|
||
delta = False
|
||
if self.measure_frequency_unit == 'day':
|
||
delta = relativedelta(days=self.measure_frequency_unit_value)
|
||
elif self.measure_frequency_unit == 'week':
|
||
delta = relativedelta(weeks=self.measure_frequency_unit_value)
|
||
elif self.measure_frequency_unit == 'month':
|
||
delta = relativedelta(months=self.measure_frequency_unit_value)
|
||
date_previous = datetime.today() - delta
|
||
checks = self.env['quality.check'].search([
|
||
('point_id', '=', self.id),
|
||
('create_date', '>=', date_previous.strftime(DEFAULT_SERVER_DATETIME_FORMAT))], limit=1)
|
||
return not(bool(checks))
|
||
return super(QualityPoint, self).check_execute_now()
|
||
|
||
def _get_type_default_domain(self):
|
||
domain = super(QualityPoint, self)._get_type_default_domain()
|
||
domain.append(('technical_name', '=', 'passfail'))
|
||
return domain
|
||
|
||
def action_see_quality_checks(self):
|
||
self.ensure_one()
|
||
action = self.env["ir.actions.actions"]._for_xml_id("quality_control.quality_check_action_main")
|
||
action['domain'] = [('point_id', '=', self.id)]
|
||
action['context'] = {
|
||
'default_company_id': self.company_id.id,
|
||
'default_point_id': self.id
|
||
}
|
||
return action
|
||
|
||
def action_see_spc_control(self):
|
||
self.ensure_one()
|
||
action = self.env["ir.actions.actions"]._for_xml_id("quality_control.quality_check_action_spc")
|
||
if self.test_type == 'measure':
|
||
action['context'] = {'group_by': ['name', 'point_id'], 'graph_measure': ['measure'], 'graph_mode': 'line'}
|
||
action['domain'] = [('point_id', '=', self.id), ('quality_state', '!=', 'none')]
|
||
return action
|
||
|
||
def _get_checks_values(self, products, company_id, existing_checks=False):
|
||
quality_points_list = []
|
||
point_values = []
|
||
if not existing_checks:
|
||
existing_checks = []
|
||
for check in existing_checks:
|
||
point_key = (check.point_id.id, check.team_id.id, check.product_id.id)
|
||
quality_points_list.append(point_key)
|
||
|
||
for point in self:
|
||
if not point.check_execute_now():
|
||
continue
|
||
point_products = point.product_ids
|
||
|
||
if point.product_category_ids:
|
||
point_product_from_categories = self.env['product.product'].search([('categ_id', 'child_of', point.product_category_ids.ids), ('id', 'in', products.ids)])
|
||
point_products |= point_product_from_categories
|
||
|
||
if not point.product_ids and not point.product_category_ids:
|
||
point_products |= products
|
||
|
||
for product in point_products:
|
||
if product not in products:
|
||
continue
|
||
point_key = (point.id, point.team_id.id, product.id)
|
||
if point_key in quality_points_list:
|
||
continue
|
||
point_values.append({
|
||
'point_id': point.id,
|
||
'measure_on': point.measure_on,
|
||
'team_id': point.team_id.id,
|
||
'product_id': product.id,
|
||
})
|
||
quality_points_list.append(point_key)
|
||
|
||
return point_values
|
||
|
||
@api.model
|
||
def _get_domain(self, product_ids, picking_type_id, measure_on='product'):
|
||
""" Helper that returns a domain for quality.point based on the products and picking type
|
||
pass as arguments. It will search for quality point having:
|
||
- No product_ids and no product_category_id
|
||
- At least one variant from product_ids
|
||
- At least one category that is a parent of the product_ids categories
|
||
|
||
:param product_ids: the products that could require a quality check
|
||
:type product: :class:`~odoo.addons.product.models.product.ProductProduct`
|
||
:param picking_type_id: the products that could require a quality check
|
||
:type product: :class:`~odoo.addons.stock.models.stock_picking.PickingType`
|
||
:return: the domain for quality point with given picking_type_id for all the product_ids
|
||
:rtype: list
|
||
"""
|
||
domain = [('picking_type_ids', 'in', picking_type_id.ids)]
|
||
domain_in_products_or_categs = ['|', ('product_ids', 'in', product_ids.ids), ('product_category_ids', 'parent_of', product_ids.categ_id.ids)]
|
||
domain_no_products_and_categs = [('product_ids', '=', False), ('product_category_ids', '=', False)]
|
||
domain += OR([domain_in_products_or_categs, domain_no_products_and_categs])
|
||
domain += [('measure_on', '=', measure_on)]
|
||
|
||
return domain
|
||
|
||
|
||
class QualityCheck(models.Model):
|
||
_inherit = "quality.check"
|
||
|
||
failure_message = fields.Html(related='point_id.failure_message', readonly=True)
|
||
measure = fields.Float('Measure', default=0.0, digits='Quality Tests', tracking=True)
|
||
measure_success = fields.Selection([
|
||
('none', 'No measure'),
|
||
('pass', 'Pass'),
|
||
('fail', 'Fail')], string="Measure Success", compute="_compute_measure_success",
|
||
readonly=True, store=True)
|
||
tolerance_min = fields.Float('Min Tolerance', related='point_id.tolerance_min', readonly=True)
|
||
tolerance_max = fields.Float('Max Tolerance', related='point_id.tolerance_max', readonly=True)
|
||
warning_message = fields.Text(compute='_compute_warning_message')
|
||
norm_unit = fields.Char(related='point_id.norm_unit', readonly=True)
|
||
qty_to_test = fields.Float(compute="_compute_qty_to_test", string="Quantity to Test", help="Quantity of product to test within the lot", digits='Product Unit of Measure')
|
||
qty_tested = fields.Float(string="Quantity Tested", help="Quantity of product tested within the lot", digits='Product Unit of Measure')
|
||
measure_on = fields.Selection([
|
||
('operation', 'Operation'),
|
||
('product', 'Product'),
|
||
('move_line', 'Quantity')], string="Control per", default='product', required=True,
|
||
help="""Operation = One quality check is requested at the operation level.
|
||
Product = A quality check is requested per product.
|
||
Quantity = A quality check is requested for each new product quantity registered, with partial quantity checks also possible.""")
|
||
move_line_id = fields.Many2one('stock.move.line', 'Stock Move Line', check_company=True, help="In case of Quality Check by Quantity, Move Line on which the Quality Check applies")
|
||
failure_location_id = fields.Many2one('stock.location', string="Failure Location")
|
||
lot_name = fields.Char('Lot/Serial Number Name', related='move_line_id.lot_name', store=True)
|
||
lot_line_id = fields.Many2one('stock.lot', store=True, compute='_compute_lot_line_id')
|
||
qty_line = fields.Float(compute='_compute_qty_line', string="Quantity")
|
||
uom_id = fields.Many2one(related='product_id.uom_id', string="Product Unit of Measure")
|
||
show_lot_text = fields.Boolean(compute='_compute_show_lot_text')
|
||
is_lot_tested_fractionally = fields.Boolean(related='point_id.is_lot_tested_fractionally')
|
||
testing_percentage_within_lot = fields.Float(related="point_id.testing_percentage_within_lot")
|
||
product_tracking = fields.Selection(related='product_id.tracking')
|
||
|
||
@api.depends('measure_success')
|
||
def _compute_warning_message(self):
|
||
for rec in self:
|
||
if rec.measure_success == 'fail':
|
||
rec.warning_message = _('You measured %.2f %s and it should be between %.2f and %.2f %s.',
|
||
rec.measure, rec.norm_unit, rec.point_id.tolerance_min,
|
||
rec.point_id.tolerance_max, rec.norm_unit
|
||
)
|
||
else:
|
||
rec.warning_message = ''
|
||
|
||
@api.depends('move_line_id.quantity')
|
||
def _compute_qty_line(self):
|
||
for qc in self:
|
||
qc.qty_line = qc.move_line_id.quantity
|
||
|
||
@api.depends('move_line_id.lot_id')
|
||
def _compute_lot_line_id(self):
|
||
for qc in self:
|
||
qc.lot_line_id = qc.move_line_id.lot_id
|
||
if qc.lot_line_id and qc._update_lot_from_lot_line():
|
||
qc.lot_id = qc.lot_line_id
|
||
|
||
def _update_lot_from_lot_line(self):
|
||
return True
|
||
|
||
@api.depends('measure')
|
||
def _compute_measure_success(self):
|
||
for rec in self:
|
||
if rec.point_id.test_type == 'passfail':
|
||
rec.measure_success = 'none'
|
||
else:
|
||
if rec.measure < rec.point_id.tolerance_min or rec.measure > rec.point_id.tolerance_max:
|
||
rec.measure_success = 'fail'
|
||
else:
|
||
rec.measure_success = 'pass'
|
||
|
||
# Add picture dependency
|
||
@api.depends('picture')
|
||
def _compute_result(self):
|
||
super(QualityCheck, self)._compute_result()
|
||
|
||
@api.depends('qty_line', 'testing_percentage_within_lot', 'is_lot_tested_fractionally')
|
||
def _compute_qty_to_test(self):
|
||
for qc in self:
|
||
if qc.is_lot_tested_fractionally:
|
||
qc.qty_to_test = float_round(qc.qty_line * qc.testing_percentage_within_lot / 100, precision_rounding=qc.product_id.uom_id.rounding or 0.01, rounding_method="UP")
|
||
else:
|
||
qc.qty_to_test = qc.qty_line
|
||
|
||
@api.depends('lot_line_id', 'move_line_id')
|
||
def _compute_show_lot_text(self):
|
||
for qc in self:
|
||
if qc.lot_line_id or not qc.move_line_id:
|
||
qc.show_lot_text = False
|
||
else:
|
||
qc.show_lot_text = True
|
||
|
||
def _is_pass_fail_applicable(self):
|
||
if self.test_type in ['passfail', 'measure']:
|
||
return True
|
||
return super()._is_pass_fail_applicable()
|
||
|
||
def _get_check_result(self):
|
||
if self.test_type == 'picture' and self.picture:
|
||
return _('Picture Uploaded')
|
||
else:
|
||
return super(QualityCheck, self)._get_check_result()
|
||
|
||
def _check_to_unlink(self):
|
||
return True
|
||
|
||
def _measure_passes(self):
|
||
self.ensure_one()
|
||
return self.point_id.tolerance_min <= self.measure <= self.point_id.tolerance_max
|
||
|
||
def do_measure(self):
|
||
self.ensure_one()
|
||
if self._measure_passes():
|
||
return self.do_pass()
|
||
else:
|
||
return self.do_fail()
|
||
|
||
def do_alert(self):
|
||
self.ensure_one()
|
||
alert = self.env['quality.alert'].create({
|
||
'check_id': self.id,
|
||
'product_id': self.product_id.id,
|
||
'product_tmpl_id': self.product_id.product_tmpl_id.id,
|
||
'lot_id': self.lot_id.id,
|
||
'user_id': self.user_id.id,
|
||
'team_id': self.team_id.id,
|
||
'company_id': self.company_id.id
|
||
})
|
||
return {
|
||
'name': _('Quality Alert'),
|
||
'type': 'ir.actions.act_window',
|
||
'res_model': 'quality.alert',
|
||
'views': [(self.env.ref('quality_control.quality_alert_view_form').id, 'form')],
|
||
'res_id': alert.id,
|
||
'context': {'default_check_id': self.id},
|
||
}
|
||
|
||
def action_see_alerts(self):
|
||
self.ensure_one()
|
||
if len(self.alert_ids) == 1:
|
||
return {
|
||
'name': _('Quality Alert'),
|
||
'type': 'ir.actions.act_window',
|
||
'res_model': 'quality.alert',
|
||
'views': [(self.env.ref('quality_control.quality_alert_view_form').id, 'form')],
|
||
'res_id': self.alert_ids.ids[0],
|
||
'context': {'default_check_id': self.id},
|
||
}
|
||
else:
|
||
action = self.env["ir.actions.actions"]._for_xml_id("quality_control.quality_alert_action_check")
|
||
action['domain'] = [('id', 'in', self.alert_ids.ids)]
|
||
action['context'] = dict(self._context, default_check_id=self.id)
|
||
return action
|
||
|
||
def action_open_quality_check_wizard(self, current_check_id=None):
|
||
check_ids = sorted(self.ids)
|
||
action = self.env["ir.actions.actions"]._for_xml_id("quality_control.action_quality_check_wizard")
|
||
check_id = self.browse(current_check_id or check_ids[0])
|
||
action['name'] = check_id._get_check_action_name()
|
||
action['context'] = self.env.context.copy()
|
||
action['context'].update({
|
||
'default_check_ids': check_ids,
|
||
'default_current_check_id': check_id.id,
|
||
'default_qty_tested': check_id.qty_to_test,
|
||
})
|
||
return action
|
||
|
||
def _can_move_line_to_failure_location(self):
|
||
self.ensure_one()
|
||
return self.quality_state == 'fail' and self.point_id.measure_on == 'move_line' and self.move_line_id and self.picking_id
|
||
|
||
def _move_line_to_failure_location(self, failure_location_id, failed_qty=None):
|
||
""" This function is used to fail move lines and can optionally:
|
||
- split it into failed and passed qties (i.e. 2 move lines w/1 check each)
|
||
- send the failed qty to a failure location
|
||
:param failure_location_id: id of location to send failed qty to
|
||
:param failed_qty: qty failed on check, defaults to None, if None all quantity of the move is failed
|
||
"""
|
||
for check in self:
|
||
if not check._can_move_line_to_failure_location():
|
||
continue
|
||
failed_qty = failed_qty or check.move_line_id.quantity
|
||
old_move_line = check.move_line_id
|
||
dest_location = failure_location_id or old_move_line.location_dest_id.id
|
||
if failure_location_id:
|
||
check.failure_location_id = failure_location_id
|
||
if failed_qty == check.move_line_id.quantity:
|
||
old_move_line.location_dest_id = dest_location
|
||
return
|
||
old_move_line.quantity -= failed_qty
|
||
failed_move_line = old_move_line.with_context(default_check_ids=None, no_checks=True).copy({
|
||
'location_dest_id': dest_location,
|
||
'quantity': failed_qty,
|
||
})
|
||
# switch the checks, check in self should always be the failed one,
|
||
# new check linked to original move line will be passed check
|
||
new_check = self.create(failed_move_line._get_check_values(check.point_id))
|
||
check.move_line_id = failed_move_line
|
||
new_check.move_line_id = old_move_line
|
||
new_check.do_pass()
|
||
|
||
def _get_check_action_name(self):
|
||
self.ensure_one()
|
||
action_name = self.title or "Quality Check"
|
||
if self.product_id:
|
||
action_name += ' : %s' % self.product_id.name
|
||
if self.qty_line and self.uom_id:
|
||
action_name += ' - %s %s' % (self.qty_line, self.uom_id.name)
|
||
if self.lot_name or self.lot_line_id:
|
||
action_name += ' - %s' % (self.lot_name or self.lot_line_id.name)
|
||
return action_name
|
||
|
||
|
||
class QualityAlert(models.Model):
|
||
_inherit = "quality.alert"
|
||
|
||
title = fields.Char('Title')
|
||
|
||
def action_see_check(self):
|
||
return {
|
||
'name': _('Quality Check'),
|
||
'type': 'ir.actions.act_window',
|
||
'view_mode': 'form',
|
||
'res_model': 'quality.check',
|
||
'target': 'current',
|
||
'res_id': self.check_id.id,
|
||
}
|
||
|
||
@api.depends('name', 'title')
|
||
def _compute_display_name(self):
|
||
for record in self:
|
||
name = record.name + ' - ' + record.title if record.title else record.name
|
||
record.display_name = name
|
||
|
||
@api.model
|
||
def name_create(self, name):
|
||
""" Create an alert with name_create should use prepend the sequence in the name """
|
||
record = self.create({
|
||
'title': name,
|
||
})
|
||
return record.id, record.display_name
|
||
|
||
@api.model
|
||
def message_new(self, msg_dict, custom_values=None):
|
||
""" Override, used with creation by email alias. The purpose of the override is
|
||
to use the subject for title and body for description instead of the name.
|
||
"""
|
||
# We need to add the name in custom_values or it will use the subject.
|
||
custom_values['name'] = self.env['ir.sequence'].next_by_code('quality.alert') or _('New')
|
||
if msg_dict.get('subject'):
|
||
custom_values['title'] = msg_dict['subject']
|
||
if msg_dict.get('body'):
|
||
custom_values['description'] = msg_dict['body']
|
||
return super(QualityAlert, self).message_new(msg_dict, custom_values)
|
||
|
||
|
||
class ProductTemplate(models.Model):
|
||
_inherit = "product.template"
|
||
|
||
quality_control_point_qty = fields.Integer(compute='_compute_quality_check_qty', groups='quality.group_quality_user')
|
||
quality_pass_qty = fields.Integer(compute='_compute_quality_check_qty', groups='quality.group_quality_user')
|
||
quality_fail_qty = fields.Integer(compute='_compute_quality_check_qty', groups='quality.group_quality_user')
|
||
|
||
@api.depends('product_variant_ids')
|
||
def _compute_quality_check_qty(self):
|
||
for product_tmpl in self:
|
||
product_tmpl.quality_fail_qty, product_tmpl.quality_pass_qty = product_tmpl.product_variant_ids._count_quality_checks()
|
||
product_tmpl.quality_control_point_qty = product_tmpl.with_context(active_test=product_tmpl.active).product_variant_ids._count_quality_points()
|
||
|
||
def action_see_quality_control_points(self):
|
||
self.ensure_one()
|
||
action = self.env["ir.actions.actions"]._for_xml_id("quality_control.quality_point_action")
|
||
action['context'] = dict(self.env.context, default_product_ids=self.product_variant_ids.ids)
|
||
|
||
domain_in_products_or_categs = ['|', ('product_ids', 'in', self.product_variant_ids.ids), ('product_category_ids', 'parent_of', self.categ_id.ids)]
|
||
domain_no_products_and_categs = [('product_ids', '=', False), ('product_category_ids', '=', False)]
|
||
action['domain'] = OR([domain_in_products_or_categs, domain_no_products_and_categs])
|
||
return action
|
||
|
||
def action_see_quality_checks(self):
|
||
self.ensure_one()
|
||
action = self.env["ir.actions.actions"]._for_xml_id("quality_control.quality_check_action_main")
|
||
action['context'] = dict(self.env.context, default_product_id=self.product_variant_id.id, create=False)
|
||
action['domain'] = [
|
||
'|',
|
||
('product_id', 'in', self.product_variant_ids.ids),
|
||
'&',
|
||
('measure_on', '=', 'operation'),
|
||
('picking_id.move_ids.product_tmpl_id', '=', self.id),
|
||
]
|
||
return action
|
||
|
||
|
||
class ProductProduct(models.Model):
|
||
_inherit = "product.product"
|
||
|
||
quality_control_point_qty = fields.Integer(compute='_compute_quality_check_qty', groups='quality.group_quality_user')
|
||
quality_pass_qty = fields.Integer(compute='_compute_quality_check_qty', groups='quality.group_quality_user')
|
||
quality_fail_qty = fields.Integer(compute='_compute_quality_check_qty', groups='quality.group_quality_user')
|
||
|
||
def _compute_quality_check_qty(self):
|
||
for product in self:
|
||
product.quality_fail_qty, product.quality_pass_qty = product._count_quality_checks()
|
||
product.quality_control_point_qty = product._count_quality_points()
|
||
|
||
def _count_quality_checks(self):
|
||
quality_fail_qty = 0
|
||
quality_pass_qty = 0
|
||
domain = [
|
||
'|',
|
||
('product_id', 'in', self.ids),
|
||
'&',
|
||
('measure_on', '=', 'operation'),
|
||
('picking_id.move_ids.product_id', 'in', self.ids),
|
||
('company_id', '=', self.env.company.id),
|
||
('quality_state', '!=', 'none')
|
||
]
|
||
quality_checks_by_state = self.env['quality.check']._read_group(domain, ['quality_state'], ['__count'])
|
||
for quality_state, count in quality_checks_by_state:
|
||
if quality_state == 'fail':
|
||
quality_fail_qty = count
|
||
elif quality_state == 'pass':
|
||
quality_pass_qty = count
|
||
|
||
return quality_fail_qty, quality_pass_qty
|
||
|
||
def _count_quality_points(self):
|
||
""" Compute the count of all related quality points, which means quality points that have either
|
||
the product in common, a product category parent of this product's category or no product/category
|
||
set at all.
|
||
"""
|
||
|
||
query = self.env['quality.point']._where_calc([('company_id', '=', self.env.company.id)])
|
||
self.env['quality.point']._apply_ir_rules(query, 'read')
|
||
_, where_clause, where_clause_args = query.get_sql()
|
||
additional_where_clause = self._additional_quality_point_where_clause()
|
||
where_clause += additional_where_clause
|
||
parent_category_ids = [int(parent_id) for parent_id in self.categ_id.parent_path.split('/')[:-1]] if self.categ_id else []
|
||
|
||
self.env.cr.execute("""
|
||
SELECT COUNT(*)
|
||
FROM quality_point
|
||
WHERE %s
|
||
AND (
|
||
(
|
||
-- QP has at least one linked product and one is right
|
||
EXISTS (SELECT 1 FROM product_product_quality_point_rel rel WHERE rel.quality_point_id = quality_point.id AND rel.product_product_id = ANY(%%s))
|
||
-- Or QP has at least one linked product category and one is right
|
||
OR EXISTS (SELECT 1 FROM product_category_quality_point_rel rel WHERE rel.quality_point_id = quality_point.id AND rel.product_category_id = ANY(%%s))
|
||
)
|
||
OR (
|
||
-- QP has no linked products
|
||
NOT EXISTS (SELECT 1 FROM product_product_quality_point_rel rel WHERE rel.quality_point_id = quality_point.id)
|
||
-- And QP has no linked product categories
|
||
AND NOT EXISTS (SELECT 1 FROM product_category_quality_point_rel rel WHERE rel.quality_point_id = quality_point.id)
|
||
)
|
||
)
|
||
""" % (where_clause,), where_clause_args + [self.ids, parent_category_ids]
|
||
)
|
||
return self.env.cr.fetchone()[0]
|
||
|
||
def action_see_quality_control_points(self):
|
||
self.ensure_one()
|
||
action = self.product_tmpl_id.action_see_quality_control_points()
|
||
action['context'].update(default_product_ids=self.ids)
|
||
|
||
domain_in_products_or_categs = ['|', ('product_ids', 'in', self.ids), ('product_category_ids', 'parent_of', self.categ_id.ids)]
|
||
domain_no_products_and_categs = [('product_ids', '=', False), ('product_category_ids', '=', False)]
|
||
action['domain'] = OR([domain_in_products_or_categs, domain_no_products_and_categs])
|
||
return action
|
||
|
||
def action_see_quality_checks(self):
|
||
self.ensure_one()
|
||
action = self.env["ir.actions.actions"]._for_xml_id("quality_control.quality_check_action_main")
|
||
action['context'] = dict(self.env.context, default_product_id=self.id, create=False)
|
||
action['domain'] = [
|
||
'|',
|
||
('product_id', '=', self.id),
|
||
'&',
|
||
('measure_on', '=', 'operation'),
|
||
('picking_id.move_ids.product_id', '=', self.id),
|
||
]
|
||
return action
|
||
|
||
def _additional_quality_point_where_clause(self):
|
||
return ""
|