332 lines
11 KiB
Python
332 lines
11 KiB
Python
# This file is part of Tryton. The COPYRIGHT file at the top level of
|
|
# this repository contains the full copyright notices and license terms.
|
|
|
|
from trytond.model import (
|
|
DeactivableMixin, MatchMixin, ModelSQL, ModelView, Workflow, fields,
|
|
sequence_ordered)
|
|
from trytond.pool import Pool, PoolMeta
|
|
from trytond.pyson import Eval, Id, If
|
|
|
|
|
|
class Location(metaclass=PoolMeta):
|
|
__name__ = 'stock.location'
|
|
|
|
shipping_points = fields.One2Many(
|
|
'stock.shipping.point', 'warehouse', "Shipping Points",
|
|
states={
|
|
'invisible': Eval('type') != 'warehouse',
|
|
})
|
|
|
|
|
|
class ShippingPoint(DeactivableMixin, ModelSQL, ModelView):
|
|
__name__ = 'stock.shipping.point'
|
|
|
|
name = fields.Char("Name", required=True)
|
|
warehouse = fields.Many2One(
|
|
'stock.location', "Warehouse", required=True,
|
|
domain=[
|
|
('type', '=', 'warehouse'),
|
|
])
|
|
|
|
@classmethod
|
|
def default_warehouse(cls):
|
|
Location = Pool().get('stock.location')
|
|
return Location.get_default_warehouse()
|
|
|
|
|
|
class ShippingPointSelection(
|
|
sequence_ordered(), MatchMixin, ModelSQL, ModelView):
|
|
__name__ = 'stock.shipping.point.selection'
|
|
|
|
warehouse = fields.Many2One(
|
|
'stock.location', "Warehouse", required=True,
|
|
domain=[
|
|
('type', '=', 'warehouse'),
|
|
])
|
|
shipping_point = fields.Many2One(
|
|
'stock.shipping.point', "Shipping Point", required=True,
|
|
domain=[
|
|
('warehouse', '=', Eval('warehouse', -1)),
|
|
])
|
|
|
|
delivery_country = fields.Many2One(
|
|
'country.country', "Country", ondelete='CASCADE',
|
|
help="Apply only when delivering to this country.\n"
|
|
"Leave empty for any country.")
|
|
contains_product_categories = fields.Many2Many(
|
|
'stock.shipping.point.selection-contains-product.category',
|
|
'selection', 'category', "Contains Product Categories",
|
|
help="Apply only when at least one product shipped "
|
|
"is in one of these categories.\n"
|
|
"Leave empty for any product category.")
|
|
|
|
@classmethod
|
|
def default_warehouse(cls):
|
|
Location = Pool().get('stock.location')
|
|
return Location.get_default_warehouse()
|
|
|
|
@classmethod
|
|
def get_shipping_point(cls, shipment, pattern=None):
|
|
pattern = pattern.copy() if pattern else {}
|
|
pattern.update(shipment.shipping_point_pattern())
|
|
selections = cls.search([
|
|
('warehouse', '=', shipment.warehouse),
|
|
])
|
|
for selection in selections:
|
|
if selection.match(pattern):
|
|
return selection.shipping_point
|
|
|
|
def match(self, pattern, match_none=False):
|
|
def parents(categories):
|
|
for category in categories:
|
|
while category:
|
|
yield category
|
|
category = category.parent
|
|
|
|
pattern = pattern.copy()
|
|
products = pattern.pop('products', [])
|
|
if self.contains_product_categories:
|
|
categories = set()
|
|
for product in set(products):
|
|
categories.update(parents(product.categories_all))
|
|
if not categories & set(self.contains_product_categories):
|
|
return False
|
|
return super().match(pattern, match_none=match_none)
|
|
|
|
|
|
class ShippingPointSelection_Contains_ProductCategory(ModelSQL):
|
|
__name__ = 'stock.shipping.point.selection-contains-product.category'
|
|
|
|
selection = fields.Many2One(
|
|
'stock.shipping.point.selection', "Selection",
|
|
required=True, ondelete='CASCADE')
|
|
category = fields.Many2One(
|
|
'product.category', "Category", required=True, ondelete='CASCADE')
|
|
|
|
|
|
class ShippingPointSelection_ProductClassification(metaclass=PoolMeta):
|
|
__name__ = 'stock.shipping.point.selection'
|
|
|
|
contains_product_classification = fields.Reference(
|
|
"Contains Product Classification",
|
|
selection='get_product_classifications',
|
|
help="Apply only when at least one product shipped "
|
|
"belongs to this classification.\n"
|
|
"Leave empty for any product classification.")
|
|
|
|
@classmethod
|
|
def get_product_classifications(cls):
|
|
pool = Pool()
|
|
Template = pool.get('product.template')
|
|
return Template.get_classification()
|
|
|
|
def match(self, pattern, match_none=False):
|
|
def parents(classification):
|
|
while classification:
|
|
yield classification
|
|
classification = classification.parent
|
|
|
|
products = pattern.get('products', [])
|
|
if self.contains_product_classification:
|
|
classifications = set()
|
|
for product in set(products):
|
|
if hasattr(product.classification, 'parent'):
|
|
classifications.update(parents(product.classification))
|
|
else:
|
|
classifications.add(product.classification)
|
|
if self.contains_product_classification not in classifications:
|
|
return False
|
|
return super().match(pattern, match_none=match_none)
|
|
|
|
|
|
class ShippingPointSelection_ShipmentMeasurements(metaclass=PoolMeta):
|
|
__name__ = 'stock.shipping.point.selection'
|
|
|
|
min_weight = fields.Float(
|
|
"Minimal Weight", digits='weight_uom',
|
|
domain=[
|
|
If(Eval('max_weight'),
|
|
['OR',
|
|
('min_weight', '=', None),
|
|
('min_weight', '<=', Eval('max_weight', 0)),
|
|
],
|
|
[]),
|
|
])
|
|
max_weight = fields.Float(
|
|
"Maximum Weight", digits='weight_uom',
|
|
domain=[
|
|
If(Eval('min_weight'),
|
|
['OR',
|
|
('max_weight', '=', None),
|
|
('max_weight', '>=', Eval('min_weight', 0)),
|
|
],
|
|
[]),
|
|
])
|
|
weight_uom = fields.Many2One(
|
|
'product.uom', "Weight UoM",
|
|
domain=[('category', '=', Id('product', 'uom_cat_weight'))],
|
|
states={
|
|
'required': Eval('min_weight') | Eval('max_weight'),
|
|
})
|
|
|
|
min_volume = fields.Float(
|
|
"Minimal Volume", digits='volume_uom',
|
|
domain=[
|
|
If(Eval('max_volume'),
|
|
['OR',
|
|
('min_volume', '=', None),
|
|
('min_volume', '<=', Eval('max_volume', 0)),
|
|
],
|
|
[]),
|
|
])
|
|
max_volume = fields.Float(
|
|
"Maximal Volume", digits='volume_uom',
|
|
domain=[
|
|
If(Eval('min_volume'),
|
|
['OR',
|
|
('max_volume', '=', None),
|
|
('max_volume', '>=', Eval('min_volume', 0)),
|
|
],
|
|
[]),
|
|
])
|
|
volume_uom = fields.Many2One(
|
|
'product.uom', "Volume UoM",
|
|
domain=[('category', '=', Id('product', 'uom_cat_volume'))],
|
|
states={
|
|
'required': Eval('min_volume') | Eval('max_volume'),
|
|
})
|
|
|
|
@classmethod
|
|
def get_shipping_point(cls, shipment, pattern=None):
|
|
pool = Pool()
|
|
UoM = pool.get('product.uom')
|
|
ModelData = pool.get('ir.model.data')
|
|
|
|
kg = UoM(ModelData.get_id('product', 'uom_kilogram'))
|
|
liter = UoM(ModelData.get_id('product', 'uom_liter'))
|
|
|
|
pattern = pattern.copy() if pattern else {}
|
|
pattern['weight'] = UoM.compute_qty(
|
|
shipment.weight_uom, shipment.weight, kg, round=False)
|
|
pattern['volume'] = UoM.compute_qty(
|
|
shipment.volume_uom, shipment.volume, liter, round=False)
|
|
return super().get_shipping_point(shipment, pattern=pattern)
|
|
|
|
def match(self, pattern, match_none=False):
|
|
pool = Pool()
|
|
UoM = pool.get('product.uom')
|
|
ModelData = pool.get('ir.model.data')
|
|
|
|
kg = UoM(ModelData.get_id('product', 'uom_kilogram'))
|
|
liter = UoM(ModelData.get_id('product', 'uom_liter'))
|
|
|
|
pattern = pattern.copy()
|
|
|
|
weight = pattern.pop('weight', 0)
|
|
if self.weight_uom:
|
|
weight = UoM.compute_qty(
|
|
kg, weight, self.weight_uom, round=False)
|
|
if self.min_weight and weight < self.min_weight:
|
|
return False
|
|
if self.max_weight and weight > self.max_weight:
|
|
return False
|
|
|
|
volume = pattern.pop('volume', 0)
|
|
if self.volume_uom:
|
|
volume = UoM.compute_qty(
|
|
liter, volume, self.volume_uom, round=False)
|
|
if self.min_volume and volume < self.min_volume:
|
|
return False
|
|
if self.max_volume and volume > self.max_volume:
|
|
return False
|
|
|
|
return super().match(pattern, match_none=match_none)
|
|
|
|
|
|
class ShippingPointMixin:
|
|
__slots__ = ()
|
|
|
|
shipping_point = fields.Many2One(
|
|
'stock.shipping.point', "Shipping Point",
|
|
domain=[
|
|
('warehouse', '=', Eval('warehouse', -1)),
|
|
],
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
})
|
|
|
|
|
|
class ShippingPointAssignMixin(ShippingPointMixin):
|
|
__slots__ = ()
|
|
|
|
def shipping_point_pattern(self):
|
|
pattern = {}
|
|
if getattr(self, 'delivery_address', None):
|
|
pattern['delivery_country'] = self.delivery_address.country
|
|
pattern['products'] = {m.product for m in self.moves}
|
|
return pattern
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
@Workflow.transition('draft')
|
|
def draft(cls, shipments):
|
|
super().draft(shipments)
|
|
cls.write(shipments, {'shipping_point': None})
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
@Workflow.transition('waiting')
|
|
def wait(cls, shipments, moves=None):
|
|
pool = Pool()
|
|
Selection = pool.get('stock.shipping.point.selection')
|
|
|
|
super().wait(shipments, moves=moves)
|
|
|
|
for shipment in shipments:
|
|
if not shipment.shipping_point:
|
|
shipment.shipping_point = Selection.get_shipping_point(
|
|
shipment)
|
|
cls.save(shipments)
|
|
|
|
|
|
class ShipmentIn(ShippingPointMixin, metaclass=PoolMeta):
|
|
__name__ = 'stock.shipment.in'
|
|
|
|
|
|
class ShipmentInReturn(ShippingPointAssignMixin, metaclass=PoolMeta):
|
|
__name__ = 'stock.shipment.in.return'
|
|
|
|
|
|
class ShipmentOut(ShippingPointAssignMixin, metaclass=PoolMeta):
|
|
__name__ = 'stock.shipment.out'
|
|
|
|
|
|
class ShipmentOutReturn(ShippingPointMixin, metaclass=PoolMeta):
|
|
__name__ = 'stock.shipment.out.return'
|
|
|
|
|
|
class ShipmentInternal(ShippingPointAssignMixin, metaclass=PoolMeta):
|
|
__name__ = 'stock.shipment.internal'
|
|
|
|
incoming_shipping_point = fields.Many2One(
|
|
'stock.shipping.point', "Incoming Shipping Point",
|
|
domain=[
|
|
('warehouse', '=', Eval('to_warehouse', -1)),
|
|
],
|
|
states={
|
|
'readonly': Eval('state') != 'shipped',
|
|
'invisible': ~Eval('transit_location'),
|
|
})
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
cls.shipping_point.string = "Outgoing Shipping Point"
|
|
cls.shipping_point.states['invisible'] = ~Eval('transit_location')
|
|
|
|
def shipping_point_pattern(self):
|
|
pattern = super().shipping_point_pattern()
|
|
if self.to_warehouse and self.to_warehouse.address:
|
|
pattern['delivery_country'] = self.to_warehouse.address.country
|
|
return pattern
|