145 lines
7.0 KiB
Python
145 lines
7.0 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.addons.base.models.res_partner import WARNING_MESSAGE, WARNING_HELP
|
|
from odoo.exceptions import ValidationError
|
|
from odoo.tools.float_utils import float_round
|
|
|
|
|
|
class ProductTemplate(models.Model):
|
|
_inherit = 'product.template'
|
|
|
|
service_type = fields.Selection(
|
|
selection=[('manual', "Manually set quantities on order")],
|
|
string="Track Service",
|
|
compute='_compute_service_type', store=True, readonly=False, precompute=True,
|
|
help="Manually set quantities on order: Invoice based on the manually entered quantity, without creating an analytic account.\n"
|
|
"Timesheets on contract: Invoice based on the tracked hours on the related timesheet.\n"
|
|
"Create a task and track hours: Create a task on the sales order validation and track the work hours.")
|
|
sale_line_warn = fields.Selection(
|
|
WARNING_MESSAGE, string="Sales Order Line",
|
|
help=WARNING_HELP, required=True, default="no-message")
|
|
sale_line_warn_msg = fields.Text(string="Message for Sales Order Line")
|
|
expense_policy = fields.Selection(
|
|
selection=[
|
|
('no', "No"),
|
|
('cost', "At cost"),
|
|
('sales_price', "Sales price"),
|
|
],
|
|
string="Re-Invoice Expenses", default='no',
|
|
compute='_compute_expense_policy', store=True, readonly=False,
|
|
help="Validated expenses and vendor bills can be re-invoiced to a customer at its cost or sales price.")
|
|
visible_expense_policy = fields.Boolean(
|
|
string="Re-Invoice Policy visible", compute='_compute_visible_expense_policy')
|
|
sales_count = fields.Float(
|
|
string="Sold", compute='_compute_sales_count', digits='Product Unit of Measure')
|
|
invoice_policy = fields.Selection(
|
|
selection=[
|
|
('order', "Ordered quantities"),
|
|
('delivery', "Delivered quantities"),
|
|
],
|
|
string="Invoicing Policy",
|
|
compute='_compute_invoice_policy', store=True, readonly=False, precompute=True,
|
|
help="Ordered Quantity: Invoice quantities ordered by the customer.\n"
|
|
"Delivered Quantity: Invoice quantities delivered to the customer.")
|
|
|
|
@api.depends('name')
|
|
def _compute_visible_expense_policy(self):
|
|
visibility = self.user_has_groups('analytic.group_analytic_accounting')
|
|
for product_template in self:
|
|
product_template.visible_expense_policy = visibility
|
|
|
|
@api.depends('sale_ok')
|
|
def _compute_expense_policy(self):
|
|
self.filtered(lambda t: not t.sale_ok).expense_policy = 'no'
|
|
|
|
@api.depends('product_variant_ids.sales_count')
|
|
def _compute_sales_count(self):
|
|
for product in self:
|
|
product.sales_count = float_round(sum([p.sales_count for p in product.with_context(active_test=False).product_variant_ids]), precision_rounding=product.uom_id.rounding)
|
|
|
|
@api.constrains('company_id')
|
|
def _check_sale_product_company(self):
|
|
"""Ensure the product is not being restricted to a single company while
|
|
having been sold in another one in the past, as this could cause issues."""
|
|
target_company = self.company_id
|
|
if target_company: # don't prevent writing `False`, should always work
|
|
subquery_products = self.env['product.product'].sudo().with_context(active_test=False)._search([('product_tmpl_id', 'in', self.ids)])
|
|
so_lines = self.env['sale.order.line'].sudo().search_read(
|
|
[('product_id', 'in', subquery_products), '!', ('company_id', 'child_of', target_company.root_id.id)],
|
|
fields=['id', 'product_id'],
|
|
)
|
|
used_products = list(map(lambda sol: sol['product_id'][1], so_lines))
|
|
if so_lines:
|
|
raise ValidationError(_('The following products cannot be restricted to the company'
|
|
' %s because they have already been used in quotations or '
|
|
'sales orders in another company:\n%s\n'
|
|
'You can archive these products and recreate them '
|
|
'with your company restriction instead, or leave them as '
|
|
'shared product.', target_company.name, ', '.join(used_products)))
|
|
|
|
def action_view_sales(self):
|
|
action = self.env['ir.actions.actions']._for_xml_id('sale.report_all_channels_sales_action')
|
|
action['domain'] = [('product_tmpl_id', 'in', self.ids)]
|
|
action['context'] = {
|
|
'pivot_measures': ['product_uom_qty'],
|
|
'active_id': self._context.get('active_id'),
|
|
'active_model': 'sale.report',
|
|
'search_default_Sales': 1,
|
|
'search_default_filter_order_date': 1,
|
|
}
|
|
return action
|
|
|
|
@api.onchange('type')
|
|
def _onchange_type(self):
|
|
res = super(ProductTemplate, self)._onchange_type()
|
|
if self._origin and self.sales_count > 0:
|
|
res['warning'] = {
|
|
'title': _("Warning"),
|
|
'message': _("You cannot change the product's type because it is already used in sales orders.")
|
|
}
|
|
return res
|
|
|
|
@api.depends('type')
|
|
def _compute_service_type(self):
|
|
self.filtered(lambda t: t.type == 'consu' or not t.service_type).service_type = 'manual'
|
|
|
|
@api.depends('type')
|
|
def _compute_invoice_policy(self):
|
|
self.filtered(lambda t: t.type == 'consu' or not t.invoice_policy).invoice_policy = 'order'
|
|
|
|
@api.model
|
|
def get_import_templates(self):
|
|
res = super(ProductTemplate, self).get_import_templates()
|
|
if self.env.context.get('sale_multi_pricelist_product_template'):
|
|
if self.user_has_groups('product.group_sale_pricelist'):
|
|
return [{
|
|
'label': _("Import Template for Products"),
|
|
'template': '/product/static/xls/product_template.xls'
|
|
}]
|
|
return res
|
|
|
|
@api.model
|
|
def _get_incompatible_types(self):
|
|
return []
|
|
|
|
@api.constrains(lambda self: self._get_incompatible_types())
|
|
def _check_incompatible_types(self):
|
|
incompatible_types = self._get_incompatible_types()
|
|
if len(incompatible_types) < 2:
|
|
return
|
|
fields = self.env['ir.model.fields'].sudo().search_read(
|
|
[('model', '=', 'product.template'), ('name', 'in', incompatible_types)],
|
|
['name', 'field_description'])
|
|
field_descriptions = {v['name']: v['field_description'] for v in fields}
|
|
field_list = incompatible_types + ['name']
|
|
values = self.read(field_list)
|
|
for val in values:
|
|
incompatible_fields = [f for f in incompatible_types if val[f]]
|
|
if len(incompatible_fields) > 1:
|
|
raise ValidationError(_(
|
|
"The product (%s) has incompatible values: %s",
|
|
val['name'],
|
|
','.join(field_descriptions[v] for v in incompatible_fields),
|
|
))
|