first commit
This commit is contained in:
root
554
modules/purchase/product.py
Normal file
554
modules/purchase/product.py
Normal file
@@ -0,0 +1,554 @@
|
||||
# This file is part of Tryton. The COPYRIGHT file at the top level of
|
||||
# this repository contains the full copyright notices and license terms.
|
||||
import datetime
|
||||
from collections import defaultdict
|
||||
|
||||
from sql import Literal
|
||||
from sql.aggregate import Count, Max
|
||||
|
||||
from trytond.i18n import gettext
|
||||
from trytond.model import (
|
||||
Index, MatchMixin, ModelSQL, ModelView, fields, sequence_ordered)
|
||||
from trytond.modules.currency.fields import Monetary
|
||||
from trytond.modules.product import (
|
||||
ProductDeactivatableMixin, price_digits, round_price)
|
||||
from trytond.pool import Pool, PoolMeta
|
||||
from trytond.pyson import Bool, Eval, If, TimeDelta
|
||||
from trytond.tools import (
|
||||
grouped_slice, is_full_text, lstrip_wildcard, reduce_ids)
|
||||
from trytond.transaction import Transaction
|
||||
|
||||
from .exceptions import PurchaseUOMWarning
|
||||
|
||||
|
||||
class Template(metaclass=PoolMeta):
|
||||
__name__ = "product.template"
|
||||
purchasable = fields.Boolean("Purchasable")
|
||||
product_suppliers = fields.One2Many(
|
||||
'purchase.product_supplier', 'template', "Suppliers",
|
||||
states={
|
||||
'invisible': (~Eval('purchasable', False)
|
||||
| ~Eval('context', {}).get('company')),
|
||||
})
|
||||
purchase_uom = fields.Many2One(
|
||||
'product.uom', "Purchase UoM",
|
||||
states={
|
||||
'invisible': ~Eval('purchasable'),
|
||||
'required': Eval('purchasable', False),
|
||||
},
|
||||
domain=[('category', '=', Eval('default_uom_category', -1))],
|
||||
help="The default Unit of Measure for purchases.")
|
||||
|
||||
@fields.depends('default_uom', 'purchase_uom', 'purchasable')
|
||||
def on_change_default_uom(self):
|
||||
try:
|
||||
super().on_change_default_uom()
|
||||
except AttributeError:
|
||||
pass
|
||||
if self.default_uom:
|
||||
if self.purchase_uom:
|
||||
if self.default_uom.category != self.purchase_uom.category:
|
||||
self.purchase_uom = self.default_uom
|
||||
else:
|
||||
self.purchase_uom = self.default_uom
|
||||
|
||||
@classmethod
|
||||
def view_attributes(cls):
|
||||
return super().view_attributes() + [
|
||||
('//page[@id="suppliers"]', 'states', {
|
||||
'invisible': ~Eval('purchasable'),
|
||||
})]
|
||||
|
||||
def product_suppliers_used(self, **pattern):
|
||||
for product_supplier in self.product_suppliers:
|
||||
if product_supplier.match(pattern):
|
||||
yield product_supplier
|
||||
|
||||
@classmethod
|
||||
def check_modification(cls, mode, templates, values=None, external=False):
|
||||
pool = Pool()
|
||||
Warning = pool.get('res.user.warning')
|
||||
|
||||
super().check_modification(
|
||||
mode, templates, values=values, external=external)
|
||||
|
||||
if mode == 'write' and values.get("purchase_uom"):
|
||||
for template in templates:
|
||||
if not template.purchase_uom:
|
||||
continue
|
||||
if template.purchase_uom.id == values["purchase_uom"]:
|
||||
continue
|
||||
for product in template.products:
|
||||
if not product.product_suppliers:
|
||||
continue
|
||||
name = '%s@product_template' % template.id
|
||||
if Warning.check(name):
|
||||
raise PurchaseUOMWarning(
|
||||
name, gettext('purchase.msg_change_purchase_uom'))
|
||||
|
||||
@classmethod
|
||||
def copy(cls, templates, default=None):
|
||||
pool = Pool()
|
||||
ProductSupplier = pool.get('purchase.product_supplier')
|
||||
if default is None:
|
||||
default = {}
|
||||
else:
|
||||
default = default.copy()
|
||||
|
||||
copy_suppliers = 'product_suppliers' not in default
|
||||
default.setdefault('product_suppliers', None)
|
||||
new_templates = super().copy(templates, default)
|
||||
if copy_suppliers:
|
||||
old2new = {}
|
||||
to_copy = []
|
||||
for template, new_template in zip(templates, new_templates):
|
||||
to_copy.extend(
|
||||
ps for ps in template.product_suppliers if not ps.product)
|
||||
old2new[template.id] = new_template.id
|
||||
if to_copy:
|
||||
ProductSupplier.copy(to_copy, {
|
||||
'template': lambda d: old2new[d['template']],
|
||||
})
|
||||
return new_templates
|
||||
|
||||
|
||||
class Product(metaclass=PoolMeta):
|
||||
__name__ = 'product.product'
|
||||
|
||||
product_suppliers = fields.One2Many(
|
||||
'purchase.product_supplier', 'product', "Suppliers",
|
||||
domain=[
|
||||
('template', '=', Eval('template', -1)),
|
||||
],
|
||||
states={
|
||||
'invisible': (~Eval('purchasable', False)
|
||||
| ~Eval('context', {}).get('company')),
|
||||
})
|
||||
purchase_price_uom = fields.Function(fields.Numeric(
|
||||
"Purchase Price", digits=price_digits), 'get_purchase_price_uom')
|
||||
last_purchase_price_uom = fields.Function(fields.Numeric(
|
||||
"Last Purchase Price", digits=price_digits),
|
||||
'get_last_purchase_price_uom')
|
||||
|
||||
@classmethod
|
||||
def get_purchase_price_uom(cls, products, name):
|
||||
quantity = Transaction().context.get('quantity') or 0
|
||||
return cls.get_purchase_price(products, quantity=quantity)
|
||||
|
||||
@classmethod
|
||||
def get_last_purchase_price_uom(cls, products, name=None):
|
||||
pool = Pool()
|
||||
Company = pool.get('company.company')
|
||||
Currency = pool.get('currency.currency')
|
||||
Date = pool.get('ir.date')
|
||||
Line = pool.get('purchase.line')
|
||||
Purchase = pool.get('purchase.purchase')
|
||||
UoM = pool.get('product.uom')
|
||||
|
||||
transaction = Transaction()
|
||||
context = transaction.context
|
||||
cursor = transaction.connection.cursor()
|
||||
purchase = Purchase.__table__()
|
||||
line = Line.__table__()
|
||||
|
||||
line_ids = []
|
||||
where = purchase.state.in_(['confirmed', 'processing', 'done'])
|
||||
supplier = context.get('supplier')
|
||||
if supplier:
|
||||
where &= purchase.party == supplier
|
||||
for sub_products in grouped_slice(products):
|
||||
query = (line
|
||||
.join(purchase, condition=line.purchase == purchase.id)
|
||||
.select(
|
||||
Max(line.id),
|
||||
where=where & reduce_ids(
|
||||
line.product, map(int, sub_products)),
|
||||
group_by=[line.product]))
|
||||
cursor.execute(*query)
|
||||
line_ids.extend(i for i, in cursor)
|
||||
lines = Line.browse(line_ids)
|
||||
|
||||
uom = None
|
||||
if context.get('uom'):
|
||||
uom = UoM(context['uom'])
|
||||
|
||||
currency = None
|
||||
if context.get('currency'):
|
||||
currency = Currency(context['currency'])
|
||||
elif context.get('company'):
|
||||
currency = Company(context['company']).currency
|
||||
date = context.get('purchase_date') or Date.today()
|
||||
|
||||
prices = defaultdict(lambda: None)
|
||||
for line in lines:
|
||||
default_uom = line.product.default_uom
|
||||
if not uom or default_uom.category != uom.category:
|
||||
product_uom = default_uom
|
||||
else:
|
||||
product_uom = uom
|
||||
unit_price = UoM.compute_price(
|
||||
line.unit, line.unit_price, product_uom)
|
||||
if currency and line.purchase.currency != currency:
|
||||
with Transaction().set_context(date=date):
|
||||
unit_price = Currency.compute(
|
||||
line.purchase.currency, unit_price, currency,
|
||||
round=False)
|
||||
prices[line.product.id] = round_price(unit_price)
|
||||
return prices
|
||||
|
||||
def product_suppliers_used(self, **pattern):
|
||||
for product_supplier in self.product_suppliers:
|
||||
if product_supplier.match(pattern):
|
||||
yield product_supplier
|
||||
pattern['product'] = None
|
||||
yield from self.template.product_suppliers_used(**pattern)
|
||||
|
||||
def _get_purchase_unit_price(self, quantity=0):
|
||||
return
|
||||
|
||||
@classmethod
|
||||
def get_purchase_price(cls, products, quantity=0):
|
||||
'''
|
||||
Return purchase price for product ids.
|
||||
The context that can have as keys:
|
||||
uom: the unit of measure
|
||||
supplier: the supplier party id
|
||||
currency: the currency id for the returned price
|
||||
'''
|
||||
pool = Pool()
|
||||
Uom = pool.get('product.uom')
|
||||
Company = pool.get('company.company')
|
||||
Currency = pool.get('currency.currency')
|
||||
Date = pool.get('ir.date')
|
||||
ProductSupplier = pool.get('purchase.product_supplier')
|
||||
ProductSupplierPrice = pool.get('purchase.product_supplier.price')
|
||||
|
||||
context = Transaction().context
|
||||
prices = {}
|
||||
|
||||
assert len(products) == len(set(products)), "Duplicate products"
|
||||
|
||||
uom = None
|
||||
if context.get('uom'):
|
||||
uom = Uom(context['uom'])
|
||||
|
||||
currency = None
|
||||
if context.get('currency'):
|
||||
currency = Currency(context['currency'])
|
||||
elif context.get('company'):
|
||||
currency = Company(context['company']).currency
|
||||
date = context.get('purchase_date') or Date.today()
|
||||
|
||||
last_purchase_prices = cls.get_last_purchase_price_uom(products)
|
||||
|
||||
for product in products:
|
||||
unit_price = product._get_purchase_unit_price(quantity=quantity)
|
||||
default_uom = product.default_uom
|
||||
default_currency = currency
|
||||
if not uom or default_uom.category != uom.category:
|
||||
product_uom = default_uom
|
||||
else:
|
||||
product_uom = uom
|
||||
pattern = ProductSupplier.get_pattern()
|
||||
product_suppliers = product.product_suppliers_used(**pattern)
|
||||
try:
|
||||
product_supplier = next(product_suppliers)
|
||||
except StopIteration:
|
||||
pass
|
||||
else:
|
||||
pattern = ProductSupplierPrice.get_pattern()
|
||||
for price in product_supplier.prices:
|
||||
if price.match(quantity, product_uom, pattern):
|
||||
unit_price = price.unit_price
|
||||
default_uom = product_supplier.unit
|
||||
default_currency = product_supplier.currency
|
||||
if unit_price is not None:
|
||||
unit_price = Uom.compute_price(
|
||||
default_uom, unit_price, product_uom)
|
||||
if currency and default_currency:
|
||||
with Transaction().set_context(date=date):
|
||||
unit_price = Currency.compute(
|
||||
default_currency, unit_price, currency,
|
||||
round=False)
|
||||
if unit_price is None:
|
||||
unit_price = last_purchase_prices[product.id]
|
||||
else:
|
||||
unit_price = round_price(unit_price)
|
||||
prices[product.id] = unit_price
|
||||
return prices
|
||||
|
||||
@classmethod
|
||||
def copy(cls, products, default=None):
|
||||
pool = Pool()
|
||||
ProductSupplier = pool.get('purchase.product_supplier')
|
||||
if default is None:
|
||||
default = {}
|
||||
else:
|
||||
default = default.copy()
|
||||
|
||||
copy_suppliers = 'product_suppliers' not in default
|
||||
if 'template' in default:
|
||||
default.setdefault('product_suppliers', None)
|
||||
new_products = super().copy(products, default)
|
||||
if 'template' in default and copy_suppliers:
|
||||
template2new = {}
|
||||
product2new = {}
|
||||
to_copy = []
|
||||
for product, new_product in zip(products, new_products):
|
||||
if product.product_suppliers:
|
||||
to_copy.extend(product.product_suppliers)
|
||||
template2new[product.template.id] = new_product.template.id
|
||||
product2new[product.id] = new_product.id
|
||||
if to_copy:
|
||||
ProductSupplier.copy(to_copy, {
|
||||
'product': lambda d: product2new[d['product']],
|
||||
'template': lambda d: template2new[d['template']],
|
||||
})
|
||||
return new_products
|
||||
|
||||
|
||||
class ProductSupplier(
|
||||
sequence_ordered(), ProductDeactivatableMixin, MatchMixin,
|
||||
ModelSQL, ModelView):
|
||||
__name__ = 'purchase.product_supplier'
|
||||
template = fields.Many2One(
|
||||
'product.template', "Product",
|
||||
required=True, ondelete='CASCADE',
|
||||
domain=[
|
||||
If(Bool(Eval('product')),
|
||||
('products', '=', Eval('product')),
|
||||
()),
|
||||
],
|
||||
states={
|
||||
'readonly': Eval('id', -1) >= 0,
|
||||
},
|
||||
context={
|
||||
'company': Eval('company', -1),
|
||||
},
|
||||
depends={'company'})
|
||||
product = fields.Many2One(
|
||||
'product.product', "Variant",
|
||||
domain=[
|
||||
If(Bool(Eval('template')),
|
||||
('template', '=', Eval('template')),
|
||||
()),
|
||||
],
|
||||
states={
|
||||
'readonly': Eval('id', -1) >= 0,
|
||||
},
|
||||
context={
|
||||
'company': Eval('company', -1),
|
||||
},
|
||||
depends={'company'})
|
||||
party = fields.Many2One(
|
||||
'party.party', 'Supplier', required=True, ondelete='CASCADE',
|
||||
states={
|
||||
'readonly': Eval('id', -1) >= 0,
|
||||
},
|
||||
context={
|
||||
'company': Eval('company', -1),
|
||||
},
|
||||
depends={'company'})
|
||||
name = fields.Char("Name", translate=True)
|
||||
code = fields.Char("Code")
|
||||
prices = fields.One2Many(
|
||||
'purchase.product_supplier.price', 'product_supplier', "Prices",
|
||||
help="Add price for different criteria.\n"
|
||||
"The last matching line is used.")
|
||||
company = fields.Many2One(
|
||||
'company.company', "Company",
|
||||
required=True, ondelete='CASCADE')
|
||||
lead_time = fields.TimeDelta(
|
||||
"Lead Time",
|
||||
domain=['OR',
|
||||
('lead_time', '=', None),
|
||||
('lead_time', '>=', TimeDelta()),
|
||||
],
|
||||
help="The time from confirming the purchase order to receiving the "
|
||||
"products.\n"
|
||||
"If empty the lead time of the supplier is used.")
|
||||
currency = fields.Many2One('currency.currency', 'Currency', required=True,
|
||||
ondelete='RESTRICT')
|
||||
unit = fields.Function(
|
||||
fields.Many2One('product.uom', "Unit"), 'on_change_with_unit')
|
||||
|
||||
@classmethod
|
||||
def __setup__(cls):
|
||||
cls.code.search_unaccented = False
|
||||
super().__setup__()
|
||||
t = cls.__table__()
|
||||
cls._sql_indexes.update({
|
||||
Index(t, (t.code, Index.Similarity())),
|
||||
})
|
||||
|
||||
@staticmethod
|
||||
def default_company():
|
||||
return Transaction().context.get('company')
|
||||
|
||||
@staticmethod
|
||||
def default_currency():
|
||||
Company = Pool().get('company.company')
|
||||
if Transaction().context.get('company'):
|
||||
company = Company(Transaction().context['company'])
|
||||
return company.currency.id
|
||||
|
||||
@fields.depends(
|
||||
'product', '_parent_product.template')
|
||||
def on_change_product(self):
|
||||
if self.product:
|
||||
self.template = self.product.template
|
||||
|
||||
@fields.depends('party')
|
||||
def on_change_party(self):
|
||||
cursor = Transaction().connection.cursor()
|
||||
self.currency = self.default_currency()
|
||||
if self.party:
|
||||
table = self.__table__()
|
||||
cursor.execute(*table.select(table.currency,
|
||||
where=table.party == self.party.id,
|
||||
group_by=table.currency,
|
||||
order_by=Count(Literal(1)).desc))
|
||||
row = cursor.fetchone()
|
||||
if row:
|
||||
self.currency, = row
|
||||
|
||||
def get_rec_name(self, name):
|
||||
if not self.name and not self.code:
|
||||
if self.product:
|
||||
name = self.product.rec_name
|
||||
else:
|
||||
name = self.template.rec_name
|
||||
else:
|
||||
if self.name:
|
||||
name = self.name
|
||||
elif self.product:
|
||||
name = self.product.name
|
||||
else:
|
||||
name = self.template.name
|
||||
if self.code:
|
||||
name = '[' + self.code + ']' + name
|
||||
return name
|
||||
|
||||
@classmethod
|
||||
def search_rec_name(cls, name, clause):
|
||||
_, operator, operand, *extra = clause
|
||||
if operator.startswith('!') or operator.startswith('not '):
|
||||
bool_op = 'AND'
|
||||
else:
|
||||
bool_op = 'OR'
|
||||
code_value = operand
|
||||
if operator.endswith('like') and is_full_text(operand):
|
||||
code_value = lstrip_wildcard(operand)
|
||||
domain = [bool_op,
|
||||
('template.rec_name', operator, operand, *extra),
|
||||
('product.rec_name', operator, operand, *extra),
|
||||
('party.rec_name', operator, operand, *extra),
|
||||
('code', operator, code_value, *extra),
|
||||
('name', operator, operand, *extra),
|
||||
]
|
||||
return domain
|
||||
|
||||
@fields.depends(
|
||||
'product', '_parent_product.purchase_uom',
|
||||
'template', '_parent_template.purchase_uom')
|
||||
def on_change_with_unit(self, name=None):
|
||||
if self.product:
|
||||
return self.product.purchase_uom
|
||||
elif self.template:
|
||||
return self.template.purchase_uom
|
||||
|
||||
@property
|
||||
def lead_time_used(self):
|
||||
# Use getattr because it can be called with an unsaved instance
|
||||
lead_time = getattr(self, 'lead_time', None)
|
||||
party = getattr(self, 'party', None)
|
||||
if lead_time is None and party:
|
||||
company = getattr(self, 'company', None)
|
||||
lead_time = party.get_multivalue(
|
||||
'supplier_lead_time', company=company.id if company else None)
|
||||
return lead_time
|
||||
|
||||
def compute_supply_date(self, date=None):
|
||||
'''
|
||||
Compute the supply date for the Product Supplier at the given date
|
||||
'''
|
||||
Date = Pool().get('ir.date')
|
||||
|
||||
if not date:
|
||||
with Transaction().set_context(company=self.company.id):
|
||||
date = Date.today()
|
||||
if self.lead_time_used is None:
|
||||
return datetime.date.max
|
||||
return date + self.lead_time_used
|
||||
|
||||
def compute_purchase_date(self, date):
|
||||
'''
|
||||
Compute the purchase date for the Product Supplier at the given date
|
||||
'''
|
||||
Date = Pool().get('ir.date')
|
||||
|
||||
if self.lead_time_used is None or date is None:
|
||||
with Transaction().set_context(company=self.company.id):
|
||||
return Date.today()
|
||||
return date - self.lead_time_used
|
||||
|
||||
@staticmethod
|
||||
def get_pattern():
|
||||
context = Transaction().context
|
||||
pattern = {'party': context.get('supplier')}
|
||||
if 'product_supplier' in context:
|
||||
pattern['id'] = context['product_supplier']
|
||||
return pattern
|
||||
|
||||
|
||||
class ProductSupplierPrice(
|
||||
sequence_ordered(), ModelSQL, ModelView, MatchMixin):
|
||||
__name__ = 'purchase.product_supplier.price'
|
||||
product_supplier = fields.Many2One('purchase.product_supplier',
|
||||
'Supplier', required=True, ondelete='CASCADE')
|
||||
quantity = fields.Float(
|
||||
"Quantity",
|
||||
required=True,
|
||||
domain=[('quantity', '>=', 0)],
|
||||
help='Minimal quantity.')
|
||||
unit_price = Monetary(
|
||||
"Unit Price", currency='currency', required=True, digits=price_digits)
|
||||
|
||||
unit = fields.Function(fields.Many2One(
|
||||
'product.uom', "Unit",
|
||||
help="The unit in which the quantity is specified."),
|
||||
'on_change_with_unit')
|
||||
currency = fields.Function(
|
||||
fields.Many2One('currency.currency', 'Currency'),
|
||||
'on_change_with_currency')
|
||||
|
||||
@classmethod
|
||||
def __setup__(cls):
|
||||
super().__setup__()
|
||||
cls.__access__.add('product_supplier')
|
||||
|
||||
@staticmethod
|
||||
def default_quantity():
|
||||
return 0.0
|
||||
|
||||
@fields.depends('product_supplier', '_parent_product_supplier.unit')
|
||||
def on_change_with_unit(self, name=None):
|
||||
return self.product_supplier.unit if self.product_supplier else None
|
||||
|
||||
@fields.depends('product_supplier', '_parent_product_supplier.currency')
|
||||
def on_change_with_currency(self, name=None):
|
||||
if self.product_supplier:
|
||||
return self.product_supplier.currency
|
||||
|
||||
@staticmethod
|
||||
def get_pattern():
|
||||
return {}
|
||||
|
||||
def match(self, quantity, unit, pattern):
|
||||
pool = Pool()
|
||||
Uom = pool.get('product.uom')
|
||||
test_quantity = Uom.compute_qty(
|
||||
self.product_supplier.unit, self.quantity, unit)
|
||||
if test_quantity > abs(quantity):
|
||||
return False
|
||||
return super().match(pattern)
|
||||
Reference in New Issue
Block a user