odoo-addon-shopfloor 16.0.1.0.0.24__py3-none-any.whl

odoo/addons/shopfloor/actions/move_line_search.py

@@ -0,0 +1,119 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo.addons.component.core import Component
+
+
+class MoveLineSearch(Component):
+    """Provide methods to search move line records.
+
+    The methods should be used in Service Components, so a search will always
+    have the same result in all scenarios.
+    """
+
+    _name = "shopfloor.search.move.line"
+    _inherit = "shopfloor.process.action"
+    _usage = "search_move_line"
+
+    @property
+    def picking_types(self):
+        return getattr(
+            self.work, "picking_types", self.env["stock.picking.type"].browse()
+        )
+
+    def _search_move_lines_by_location_domain(
+        self,
+        locations,
+        picking_type=None,
+        package=None,
+        product=None,
+        lot=None,
+        match_user=False,
+        picking_ready=True,
+        # When True, adds the package in the domain even if the package is False
+        enforce_empty_package=False,
+    ):
+        domain = [
+            ("location_id", "child_of", locations.ids),
+            ("qty_done", "=", 0),
+            ("state", "in", ("assigned", "partially_available")),
+        ]
+        if picking_type:
+            # auto_join in place for this field
+            domain += [("picking_id.picking_type_id", "=", picking_type.id)]
+        elif self.picking_types:
+            domain += [("picking_id.picking_type_id", "in", self.picking_types.ids)]
+        if package or package is not None and enforce_empty_package:
+            domain += [("package_id", "=", package.id if package else False)]
+        if product:
+            domain += [("product_id", "=", product.id)]
+        if lot:
+            domain += [("lot_id", "=", lot.id)]
+        if match_user:
+            domain += [
+                "|",
+                ("shopfloor_user_id", "=", False),
+                ("shopfloor_user_id", "=", self.env.uid),
+            ]
+        if picking_ready:
+            domain += [("picking_id.state", "=", "assigned")]
+        return domain
+
+    def search_move_lines_by_location(
+        self,
+        locations,
+        picking_type=None,
+        package=None,
+        product=None,
+        lot=None,
+        order="priority",
+        match_user=False,
+        sort_keys_func=None,
+        picking_ready=True,
+        enforce_empty_package=False,
+    ):
+        """Find lines that potentially need work in given locations."""
+        move_lines = self.env["stock.move.line"].search(
+            self._search_move_lines_by_location_domain(
+                locations,
+                picking_type,
+                package,
+                product,
+                lot,
+                match_user=match_user,
+                picking_ready=picking_ready,
+                enforce_empty_package=enforce_empty_package,
+            )
+        )
+        sort_keys_func = sort_keys_func or self._sort_key_move_lines(order)
+        move_lines = move_lines.sorted(sort_keys_func)
+        return move_lines
+
+    @staticmethod
+    def _sort_key_move_lines(order):
+        """Return a sorting function to order lines."""
+
+        if order == "priority":
+            # make prority negative to keep sorting ascending
+            return lambda line: (
+                -int(line.move_id.priority or "0"),
+                line.move_id.date,
+                line.move_id.id,
+            )
+        elif order == "location":
+            return lambda line: (
+                line.move_id.location_id.shopfloor_picking_sequence or "",
+                line.move_id.location_id.name,
+                line.move_id.date,
+                line.move_id.id,
+            )
+        return lambda line: line
+
+    def counters_for_lines(self, lines):
+        # Not using mapped/filtered to support simple lists and generators
+        priority_lines = [x for x in lines if int(x.picking_id.priority or "0") > 0]
+        return {
+            "lines_count": len(lines),
+            "picking_count": len({x.picking_id.id for x in lines}),
+            "priority_lines_count": len(priority_lines),
+            "priority_picking_count": len({x.picking_id.id for x in priority_lines}),
+        }

odoo/addons/shopfloor/actions/packaging.py

@@ -0,0 +1,59 @@
+# Copyright 2021 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo.addons.component.core import Component
+
+
+class PackagingAction(Component):
+    """Provide methods to work with packaging operations."""
+
+    _name = "shopfloor.packaging.action"
+    _inherit = "shopfloor.process.action"
+    _usage = "packaging"
+
+    def packaging_valid_for_carrier(self, packaging, carrier):
+        return self.packaging_type_valid_for_carrier(packaging.package_type_id, carrier)
+
+    def packaging_type_valid_for_carrier(self, packaging_type, carrier):
+        return packaging_type.package_carrier_type in (
+            "none",
+            carrier.delivery_type,
+        )
+
+    def create_delivery_package(self, carrier):
+        default_packaging = self._get_default_packaging(carrier)
+        return self.create_package_from_packaging(default_packaging)
+
+    def _get_default_packaging(self, carrier):
+        # TODO: refactor `delivery_[carrier_name]` modules
+        # to have always the same field named `default_packaging_id`
+        # to unify lookup of this field.
+        # As alternative add a computed field.
+        # AFAIS there's no reason to have 1 field per carrier type.
+        fname = carrier.delivery_type + "_default_packaging_id"
+        if fname not in carrier._fields:
+            return self.env["stock.package.type"].browse()
+        return carrier[fname]
+
+    def create_package_from_packaging(self, packaging=None):
+        if packaging:
+            vals = self._package_vals_from_packaging(packaging)
+        else:
+            vals = self._package_vals_without_packaging()
+        return self.env["stock.quant.package"].create(vals)
+
+    def _package_vals_from_packaging(self, packaging):
+        return {
+            "package_type_id": packaging.id,
+            "pack_length": packaging.packaging_length,
+            "width": packaging.width,
+            "height": packaging.height,
+        }
+
+    def _package_vals_without_packaging(self):
+        return {}
+
+    def package_has_several_products(self, package):
+        return len(package.quant_ids.product_id) > 1
+
+    def package_has_several_lots(self, package):
+        return len(package.quant_ids.lot_id) > 1

odoo/addons/shopfloor/actions/savepoint.py

@@ -0,0 +1,44 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+import uuid
+
+from psycopg2 import sql
+
+from odoo.addons.component.core import Component
+
+
+class SavepointBuilder(Component):
+    """Return a new Savepoint instance"""
+
+    _name = "shopfloor.savepoint.action"
+    _inherit = "shopfloor.process.action"
+    _usage = "savepoint"
+
+    def new(self):
+        return Savepoint(self.env.cr)
+
+
+class Savepoint(object):
+    """Wrapper for SQL Savepoint
+
+    Close to "cr.savepoint()" context manager but this class gives more control
+    over when the release/rollback are called.
+    """
+
+    def __init__(self, cr):
+        self._cr = cr
+        self.name = uuid.uuid1().hex
+        self._cr.flush()
+        self._execute("SAVEPOINT {}")
+
+    def rollback(self):
+        self._cr.clear()
+        self._execute("ROLLBACK TO SAVEPOINT {}")
+
+    def release(self):
+        self._cr.flush()
+        self._execute("RELEASE SAVEPOINT {}")
+
+    def _execute(self, query):
+        # pylint: disable=sql-injection
+        self._cr.execute(sql.SQL(query).format(sql.Identifier(self.name)))

odoo/addons/shopfloor/actions/schema.py

@@ -0,0 +1,182 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo.addons.component.core import Component
+
+
+class ShopfloorSchemaAction(Component):
+
+    _inherit = "shopfloor.schema.action"
+
+    def picking(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+            "origin": {"type": "string", "nullable": True, "required": False},
+            "note": {"type": "string", "nullable": True, "required": False},
+            "move_line_count": {"type": "integer", "nullable": True, "required": True},
+            "package_level_count": {
+                "type": "integer",
+                "nullable": True,
+                "required": True,
+            },
+            "bulk_line_count": {"type": "integer", "nullable": True, "required": True},
+            "weight": {"required": True, "nullable": True, "type": "float"},
+            "partner": self._schema_dict_of(self._simple_record()),
+            "carrier": self._schema_dict_of(self._simple_record(), required=False),
+            "ship_carrier": self._schema_dict_of(self._simple_record(), required=False),
+            "scheduled_date": {"type": "string", "nullable": False, "required": True},
+            "progress": {"type": "float", "nullable": True},
+        }
+
+    def move_line(self, with_packaging=False, with_picking=False):
+        schema = {
+            "id": {"type": "integer", "required": True},
+            "qty_done": {"type": "float", "required": True},
+            "quantity": {"type": "float", "required": True},
+            "product": self._schema_dict_of(self.product()),
+            "lot": {
+                "type": "dict",
+                "required": False,
+                "nullable": True,
+                "schema": self.lot(),
+            },
+            "package_src": self._schema_dict_of(
+                self.package(with_packaging=with_packaging)
+            ),
+            "package_dest": self._schema_dict_of(
+                self.package(with_packaging=with_packaging), required=False
+            ),
+            "location_src": self._schema_dict_of(self.location()),
+            "location_dest": self._schema_dict_of(self.location()),
+            "priority": {"type": "string", "nullable": True, "required": False},
+            "progress": {"type": "float", "nullable": True},
+        }
+        if with_picking:
+            schema["picking"] = self._schema_dict_of(self.picking())
+        return schema
+
+    def move(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "priority": {"type": "string", "required": False, "nullable": True},
+            "quantity_done": {"type": "float", "required": True},
+            "quantity": {"type": "float", "required": True},
+            "product": self._schema_dict_of(self.product()),
+            "location_src": self._schema_dict_of(self.location()),
+            "location_dest": self._schema_dict_of(self.location()),
+            "progress": {"type": "float", "nullable": True},
+        }
+
+    def product(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+            "display_name": {"type": "string", "nullable": False, "required": True},
+            "default_code": {"type": "string", "nullable": True, "required": True},
+            "barcode": {"type": "string", "nullable": True, "required": False},
+            "supplier_code": {"type": "string", "nullable": True, "required": False},
+            "packaging": self._schema_list_of(self.packaging()),
+            "uom": self._schema_dict_of(
+                self._simple_record(
+                    factor={"required": True, "nullable": True, "type": "float"},
+                    rounding={"required": True, "nullable": True, "type": "float"},
+                )
+            ),
+        }
+
+    def package(self, with_packaging=False):
+        schema = {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+            "weight": {"required": True, "nullable": True, "type": "float"},
+            "move_line_count": {"required": False, "nullable": True, "type": "integer"},
+            "storage_type": self._schema_dict_of(self._simple_record()),
+        }
+        if with_packaging:
+            schema["packaging"] = self._schema_dict_of(self.packaging())
+        return schema
+
+    def lot(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+            "ref": {"type": "string", "nullable": True, "required": False},
+            "expiration_date": {"type": "string", "nullable": True, "required": False},
+        }
+
+    def location(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+            "barcode": {"type": "string", "nullable": True, "required": False},
+            "operation_progress": {
+                "type": "dict",
+                "required": False,
+                "schema": {
+                    "done": {"type": "float", "required": False},
+                    "to_do": {"type": "float", "required": False},
+                },
+            },
+        }
+
+    def packaging(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+            "code": {"type": "string", "nullable": True, "required": True},
+            "qty": {"type": "float", "required": True},
+        }
+
+    def delivery_packaging(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+            "packaging_type": {"type": "string", "nullable": True, "required": True},
+            "barcode": {"type": "string", "nullable": True, "required": True},
+        }
+
+    def picking_batch(self, with_pickings=False):
+        schema = {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+            "picking_count": {"required": True, "type": "integer"},
+            "move_line_count": {"required": True, "type": "integer"},
+            "weight": {"required": True, "nullable": True, "type": "float"},
+        }
+        if with_pickings:
+            schema["pickings"] = self._schema_list_of(self.picking())
+        return schema
+
+    def package_level(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "is_done": {"type": "boolean", "nullable": False, "required": True},
+            "picking": self._schema_dict_of(self._simple_record()),
+            "package_src": self._schema_dict_of(self.package()),
+            "location_src": self._schema_dict_of(self.location()),
+            "location_dest": self._schema_dict_of(self.location()),
+            "product": self._schema_dict_of(self.product()),
+            "quantity": {"type": "float", "required": True},
+        }
+
+    def picking_type(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+        }
+
+    def move_lines_counters(self):
+        return {
+            "lines_count": {"type": "float", "required": False, "nullable": True},
+            "picking_count": {"type": "float", "required": False, "nullable": True},
+            "priority_lines_count": {
+                "type": "float",
+                "required": False,
+                "nullable": True,
+            },
+            "priority_picking_count": {
+                "type": "float",
+                "required": False,
+                "nullable": True,
+            },
+        }

odoo/addons/shopfloor/actions/schema_detail.py

@@ -0,0 +1,98 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo.addons.component.core import Component
+
+
+class ShopfloorSchemaDetailAction(Component):
+    _inherit = "shopfloor.schema.detail.action"
+
+    def location_detail(self):
+        schema = self.location()
+        schema.update(
+            {
+                "complete_name": {
+                    "type": "string",
+                    "nullable": False,
+                    "required": True,
+                },
+                "reserved_move_lines": self._schema_list_of(self.move_line()),
+            }
+        )
+        return schema
+
+    def picking_detail(self):
+        schema = self.picking()
+        schema.update(
+            {
+                "picking_type_code": {
+                    "type": "string",
+                    "nullable": True,
+                    "required": False,
+                },
+                "priority": {"type": "string", "nullable": True, "required": False},
+                "operation_type": self._schema_dict_of(self._simple_record()),
+                "move_lines": self._schema_list_of(self.move_line()),
+            }
+        )
+        return schema
+
+    def package_detail(self):
+        schema = self.package(with_packaging=True)
+        schema.update(
+            {
+                "pickings": self._schema_list_of(self.picking()),
+                "move_lines": self._schema_list_of(self.move_line()),
+                "location": self._schema_dict_of(self._simple_record()),
+            }
+        )
+        return schema
+
+    def lot_detail(self):
+        schema = self.lot()
+        schema.update(
+            {
+                "removal_date": {"type": "string", "nullable": True, "required": False},
+                "expire_date": {"type": "string", "nullable": True, "required": False},
+                "product": self._schema_dict_of(self.product_detail()),
+                # TODO: packaging
+            }
+        )
+        return schema
+
+    def product(self):
+        schema = super().product()
+        schema.update(
+            {
+                "qty_available": {"type": "float", "required": True},
+                "qty_reserved": {"type": "float", "required": True},
+            }
+        )
+        return schema
+
+    def product_detail(self):
+        schema = self.product()
+        schema.update(
+            {
+                "image": {"type": "string", "nullable": True, "required": False},
+                "manufacturer": self._schema_dict_of(self._simple_record()),
+                "suppliers": self._schema_list_of(self.product_supplierinfo()),
+            }
+        )
+        return schema
+
+    def product_supplierinfo(self):
+        return {
+            "id": {"required": True, "type": "integer"},
+            "partner": {"type": "string", "nullable": True, "required": False},
+            "product_name": {"type": "string", "nullable": True, "required": False},
+            "product_code": {"type": "string", "nullable": True, "required": False},
+        }
+
+    # TODO
+    # def packaging_detail(self):
+    #     schema = self.packaging()
+    #     schema.update(
+    #         {
+    #         }
+    #     )
+    #     return schema