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

odoo/addons/shopfloor/actions/data.py

@@ -0,0 +1,329 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import fields
+
+from odoo.addons.component.core import Component
+from odoo.addons.shopfloor_base.utils import ensure_model
+
+
+class DataAction(Component):
+    _inherit = "shopfloor.data.action"
+
+    @ensure_model("stock.location")
+    def location(self, record, **kw):
+        parser = self._location_parser
+        data = self._jsonify(record.with_context(location=record.id), parser, **kw)
+        if "with_operation_progress" in kw:
+            operation_progress = self._get_location_operations_progress(record)
+            data.update({"operation_progress": operation_progress})
+        return data
+
+    def locations(self, record, **kw):
+        return self.location(record, multi=True)
+
+    def _get_location_operations_progress(self, location):
+        lines = self.env["stock.move.line"].search(
+            [
+                ("location_id", "=", location.id),
+                ("state", "in", ["partially_available", "assigned"]),
+                ("picking_id.state", "=", "assigned"),
+            ]
+        )
+        # operations_to_do = number of total operations that are pending for this location.
+        # operations_done = number of operations already done.
+        # A line with an assigned package counts as 1 operation.
+        operations_to_do = 0
+        operations_done = 0
+        for line in lines:
+            operations_done += line.qty_done if not line.package_id else 1
+            operations_to_do += line.reserved_uom_qty if not line.package_id else 1
+        return {
+            "done": operations_done,
+            "to_do": operations_to_do,
+        }
+
+    @property
+    def _location_parser(self):
+        return [
+            "id",
+            "name",
+            # Fallback to name if barcode is not valued.
+            ("barcode", lambda rec, fname: rec[fname] if rec[fname] else rec.name),
+        ]
+
+    @ensure_model("stock.picking")
+    def picking(self, record, **kw):
+        parser = self._picking_parser
+        # progress is a heavy computed field,
+        # and it may reduce performance significatively
+        # when dealing with a large number of pickings.
+        # Thus, we make it optional.
+        if "with_progress" in kw:
+            parser.append("progress")
+        return self._jsonify(record, parser, **kw)
+
+    def pickings(self, record, **kw):
+        return self.picking(record, multi=True)
+
+    @property
+    def _picking_parser(self, **kw):
+        return [
+            "id",
+            "name",
+            "origin",
+            "note",
+            ("partner_id:partner", self._partner_parser),
+            ("carrier_id:carrier", self._simple_record_parser()),
+            ("ship_carrier_id:ship_carrier", self._simple_record_parser()),
+            "move_line_count",
+            "package_level_count",
+            "bulk_line_count",
+            "total_weight:weight",
+            "scheduled_date",
+        ]
+
+    @ensure_model("stock.quant.package")
+    def package(self, record, picking=None, with_packaging=False, **kw):
+        """Return data for a stock.quant.package
+
+        If a picking is given, it will include the number of lines of the package
+        for the picking.
+        """
+        parser = self._package_parser
+        if with_packaging:
+            parser += self._package_packaging_parser
+        data = self._jsonify(record, parser, **kw)
+        # handle special cases
+        if data and picking:
+            lines = picking.move_line_ids.filtered(
+                lambda l: l.result_package_id == record
+                and l.state in ["partially_available", "assigned", "done"]
+            )
+            data.update({"move_line_count": len(lines)})
+        return data
+
+    def packages(self, records, picking=None, **kw):
+        return [self.package(rec, picking=picking, **kw) for rec in records]
+
+    @property
+    def _package_parser(self):
+        return [
+            "id",
+            "name",
+            "shopfloor_weight:weight",
+            ("package_type_id:storage_type", ["id", "name"]),
+        ]
+
+    @property
+    def _package_packaging_parser(self):
+        return [
+            ("product_packaging_id:packaging", self._packaging_parser),
+        ]
+
+    @ensure_model("product.packaging")
+    def packaging(self, record, **kw):
+        return self._jsonify(record, self._packaging_parser, **kw)
+
+    def packaging_list(self, record, **kw):
+        return self.packaging(record, multi=True)
+
+    @property
+    def _packaging_parser(self):
+        return [
+            "id",
+            ("packaging_level_id:name", lambda rec, fname: rec.packaging_level_id.name),
+            ("packaging_level_id:code", lambda rec, fname: rec.packaging_level_id.code),
+            "qty",
+        ]
+
+    @ensure_model("stock.package.type")
+    def delivery_packaging(self, record, **kw):
+        return self._jsonify(record, self._delivery_packaging_parser, **kw)
+
+    def delivery_packaging_list(self, records, **kw):
+        return self.delivery_packaging(records, multi=True)
+
+    @property
+    def _delivery_packaging_parser(self):
+        return [
+            "id",
+            "name",
+            "package_carrier_type:packaging_type",
+            "barcode",
+        ]
+
+    @ensure_model("stock.lot")
+    def lot(self, record, **kw):
+        return self._jsonify(record, self._lot_parser, **kw)
+
+    def lots(self, record, **kw):
+        return self.lot(record, multi=True)
+
+    @property
+    def _lot_parser(self):
+        return self._simple_record_parser() + ["ref", "expiration_date"]
+
+    @ensure_model("stock.move.line")
+    def move_line(self, record, with_picking=False, **kw):
+        record = record.with_context(location=record.location_id.id)
+        parser = self._move_line_parser
+        if with_picking:
+            parser += [("picking_id:picking", self._picking_parser)]
+        data = self._jsonify(record, parser)
+        if data:
+            data.update(
+                {
+                    # cannot use sub-parser here
+                    # because result might depend on picking
+                    "package_src": self.package(
+                        record.package_id, record.picking_id, **kw
+                    ),
+                    "package_dest": self.package(
+                        record.result_package_id.with_context(
+                            picking_id=record.picking_id.id
+                        ),
+                        record.picking_id,
+                        **kw,
+                    ),
+                }
+            )
+        return data
+
+    def move_lines(self, records, **kw):
+        return [self.move_line(rec, **kw) for rec in records]
+
+    @property
+    def _move_line_parser(self):
+        return [
+            "id",
+            "qty_done",
+            "reserved_uom_qty:quantity",
+            ("product_id:product", self._product_parser),
+            ("lot_id:lot", self._lot_parser),
+            ("location_id:location_src", self._location_parser),
+            ("location_dest_id:location_dest", self._location_parser),
+            (
+                "move_id:priority",
+                lambda rec, fname: rec.move_id.priority or "",
+            ),
+            "progress",
+        ]
+
+    @ensure_model("stock.move")
+    def move(self, record, **kw):
+        record = record.with_context(location=record.location_id.id)
+        parser = self._move_parser
+        return self._jsonify(record, parser)
+
+    def moves(self, records, **kw):
+        return [self.move(rec, **kw) for rec in records]
+
+    @property
+    def _move_parser(self):
+        return [
+            "id",
+            "quantity_done",
+            "product_uom_qty:quantity",
+            ("product_id:product", self._product_parser),
+            ("location_id:location_src", self._location_parser),
+            ("location_dest_id:location_dest", self._location_parser),
+            "priority",
+            "progress",
+        ]
+
+    @ensure_model("stock.package_level")
+    def package_level(self, record, **kw):
+        return self._jsonify(record, self._package_level_parser)
+
+    def package_levels(self, records, **kw):
+        return [self.package_level(rec, **kw) for rec in records]
+
+    @property
+    def _package_level_parser(self):
+        return [
+            "id",
+            "is_done",
+            ("picking_id:picking", self._simple_record_parser()),
+            ("package_id:package_src", self._package_parser),
+            ("location_dest_id:location_dest", self._location_parser),
+            (
+                "location_id:location_src",
+                lambda rec, fname: self.location(
+                    fields.first(rec.move_line_ids).location_id
+                    or fields.first(rec.move_lines).location_id
+                    or rec.picking_id.location_id
+                ),
+            ),
+            # tnx to stock_quant_package_product_packaging
+            (
+                "package_id:product",
+                lambda rec, fname: self.product(rec.package_id.single_product_id),
+            ),
+            # TODO: allow to pass mapped path to jsonifier
+            (
+                "package_id:quantity",
+                lambda rec, fname: rec.package_id.single_product_qty,
+            ),
+        ]
+
+    @ensure_model("product.product")
+    def product(self, record, **kw):
+        return self._jsonify(record, self._product_parser, **kw)
+
+    def products(self, record, **kw):
+        return self.product(record, multi=True)
+
+    @property
+    def _product_parser(self):
+        return [
+            "id",
+            "name",
+            "display_name",
+            "default_code",
+            "barcode",
+            ("packaging_ids:packaging", self._product_packaging),
+            ("uom_id:uom", self._simple_record_parser() + ["factor", "rounding"]),
+            ("seller_ids:supplier_code", self._product_supplier_code),
+        ]
+
+    def _product_packaging(self, rec, field):
+        return self._jsonify(
+            rec.packaging_ids.filtered(lambda x: x.qty),
+            self._packaging_parser,
+            multi=True,
+        )
+
+    def _product_supplier_code(self, rec, field):
+        supplier_info = fields.first(
+            rec.seller_ids.filtered(lambda x: x.product_id == rec)
+        )
+        return supplier_info.product_code or ""
+
+    @ensure_model("stock.picking.batch")
+    def picking_batch(self, record, with_pickings=False, **kw):
+        parser = self._picking_batch_parser
+        if with_pickings:
+            parser.append(("picking_ids:pickings", self._picking_parser))
+        return self._jsonify(record, parser, **kw)
+
+    def picking_batches(self, record, with_pickings=False, **kw):
+        return self.picking_batch(record, with_pickings=with_pickings, multi=True)
+
+    @property
+    def _picking_batch_parser(self):
+        return ["id", "name", "picking_count", "move_line_count", "total_weight:weight"]
+
+    @ensure_model("stock.picking.type")
+    def picking_type(self, record, **kw):
+        parser = self._picking_type_parser
+        return self._jsonify(record, parser, **kw)
+
+    def picking_types(self, record, **kw):
+        return self.picking_type(record, multi=True)
+
+    @property
+    def _picking_type_parser(self):
+        return [
+            "id",
+            "name",
+        ]

odoo/addons/shopfloor/actions/data_detail.py

@@ -0,0 +1,154 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo.tools.float_utils import float_round
+
+from odoo.addons.component.core import Component
+from odoo.addons.shopfloor_base.utils import ensure_model
+
+
+class DataDetailAction(Component):
+    _inherit = "shopfloor.data.detail.action"
+
+    def _select_value_to_label(self, rec, fname):
+        return rec._fields[fname].convert_to_export(rec[fname], rec)
+
+    def location_detail(self, record, **kw):
+        return self._jsonify(
+            record.with_context(location=record.id), self._location_detail_parser, **kw
+        )
+
+    def locations_detail(self, record, **kw):
+        return self.location_detail(record, multi=True)
+
+    @property
+    def _location_detail_parser(self):
+        return self._location_parser + [
+            "complete_name",
+            (
+                "reserved_move_line_ids:reserved_move_lines",
+                lambda record, fname: self.move_lines(record[fname]),
+            ),
+        ]
+
+    @ensure_model("stock.picking")
+    def picking_detail(self, record, **kw):
+        parser = self._picking_detail_parser
+        # progress is a heavy computed field,
+        # and it may reduce performance significatively
+        # when dealing with a large number of pickings.
+        # Thus, we make it optional.
+        if "with_progress" in kw:
+            parser.append("progress")
+        return self._jsonify(record, parser, **kw)
+
+    def pickings_detail(self, record, **kw):
+        return self.picking_detail(record, multi=True)
+
+    @property
+    def _picking_detail_parser(self):
+        return self._picking_parser + [
+            "picking_type_code",
+            ("priority", self._select_value_to_label),
+            "scheduled_date",
+            ("picking_type_id:operation_type", ["id", "name"]),
+            (
+                "move_line_ids:move_lines",
+                lambda record, fname: self.move_lines(record[fname]),
+            ),
+        ]
+
+    def package_detail(self, record, picking=None, **kw):
+        # Define a new method to not overload the base one which is used in many places
+        data = self.package(record, picking=picking, with_packaging=True, **kw)
+        data.update(self._jsonify(record, self._package_detail_parser, **kw))
+        return data
+
+    def packages_detail(self, records, picking=None, **kw):
+        return [self.package_detail(rec, picking=picking) for rec in records]
+
+    @property
+    def _package_detail_parser(self):
+        return [
+            (
+                "reserved_move_line_ids:pickings",
+                lambda record, fname: self.pickings(record[fname].mapped("picking_id")),
+            ),
+            (
+                "reserved_move_line_ids:move_lines",
+                lambda record, fname: self.move_lines(record[fname]),
+            ),
+            ("location_id:location", ["id", "display_name:name"]),
+        ]
+
+    @ensure_model("stock.lot")
+    def lot_detail(self, record, **kw):
+        # Define a new method to not overload the base one which is used in many places
+        return self._jsonify(record, self._lot_detail_parser, **kw)
+
+    def lots_detail(self, record, **kw):
+        return self.lot_detail(record, multi=True)
+
+    @property
+    def _lot_detail_parser(self):
+        return self._lot_parser + [
+            "removal_date",
+            "expiration_date:expire_date",
+            (
+                "product_id:product",
+                lambda record, fname: self.product_detail(record[fname]),
+            ),
+        ]
+
+    @ensure_model("product.product")
+    def product_detail(self, record, **kw):
+        # Defined new method to not overload the base one used in many places
+        data = self._jsonify(record, self._product_detail_parser, **kw)
+        suppliers = self.env["product.supplierinfo"].search(
+            [("product_id", "=", record.id)]
+        )
+        data["suppliers"] = self._jsonify(
+            suppliers, self._product_supplierinfo_parser, multi=True
+        )
+        return data
+
+    def products_detail(self, record, **kw):
+        return self.product_detail(record, multi=True)
+
+    @property
+    def _product_parser(self):
+        return super()._product_parser + [
+            "qty_available",
+            ("free_qty:qty_reserved", self._product_reserved_qty_subparser),
+        ]
+
+    def _product_reserved_qty_subparser(self, rec, field_name):
+        # free_qty = qty_available - reserved_quantity
+        return float_round(
+            rec.qty_available - rec[field_name], precision_rounding=rec.uom_id.rounding
+        )
+
+    @property
+    def _product_detail_parser(self):
+        return self._product_parser + [
+            ("image_128:image", self._product_image_url),
+            (
+                "product_tmpl_id:manufacturer",
+                lambda rec, fname: self._jsonify(
+                    rec.product_tmpl_id.manufacturer_id, ["id", "name"]
+                ),
+            ),
+        ]
+
+    def _product_image_url(self, record, field_name):
+        if not record[field_name]:
+            return None
+        return "/web/image/product.product/{}/{}".format(record.id, field_name)
+
+    @property
+    def _product_supplierinfo_parser(self):
+        return [
+            ("id", lambda rec, fname: rec.partner_id.id),
+            ("partner_id:partner", lambda rec, fname: rec.partner_id.name),
+            "product_name",
+            "product_code",
+        ]

odoo/addons/shopfloor/actions/inventory.py

@@ -0,0 +1,150 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import _, fields
+
+from odoo.addons.component.core import Component
+
+
+class InventoryAction(Component):
+    """Provide methods to work with inventories
+
+    Several processes have to create inventories at some point,
+    for instance when there is a stock issue.
+    """
+
+    _name = "shopfloor.inventory.action"
+    _inherit = "shopfloor.process.action"
+    _usage = "inventory"
+
+    @property
+    def inventory_model(self):
+        # the _sf_inventory key bypass groups checks,
+        # see comment in models/stock_inventory.py
+        return self.env["stock.quant"].with_context(_sf_inventory=True)
+
+    def create_draft_check_empty(self, location, product, ref=None):
+        """Create a draft inventory for a product with a zero quantity"""
+        return self._create_draft_inventory(location, product)
+
+    def _inventory_exists(self, location, product, package=None, lot=None):
+        """Return if an inventory for location and product exist"""
+        domain = [
+            ("location_id", "=", location.id),
+            ("product_id", "=", product.id),
+            ("inventory_quantity_set", "=", True),
+        ]
+        if package is not None:
+            domain.append(("package_id", "=", package.id))
+        if lot is not None:
+            domain.append(("lot_id", "=", lot.id))
+        return self.inventory_model.search_count(domain)
+
+    def _get_existing_quant(self, location, product, package=None, lot=None, limit=1):
+        domain = [("location_id", "=", location.id), ("product_id", "=", product.id)]
+        if package is not None:
+            domain.append(("package_id", "=", package.id))
+        else:
+            domain.append(("package_id", "=", False))
+        if lot is not None:
+            domain.append(("lot_id", "=", lot.id))
+        else:
+            domain.append(("lot_id", "=", False))
+        return self.inventory_model.search(domain, limit=limit)
+
+    def _create_draft_inventory(self, location, product, package=None, lot=None):
+        quants = self._get_existing_quant(
+            location, product, package=package, lot=lot, limit=None
+        )
+        if quants:
+            for quant in quants:
+                if quant.inventory_quantity_set:
+                    continue
+                quants.write(
+                    {
+                        # Set an inventory quantity to prevent the zero quant cleanup
+                        "inventory_quantity": quant.inventory_quantity + 1,
+                        "inventory_date": fields.Date.today(),
+                    }
+                )
+            return quants
+        else:
+            return self.inventory_model.sudo().create(
+                {
+                    "location_id": location.id,
+                    "product_id": product.id,
+                    "lot_id": lot.id,
+                    "inventory_quantity": 1,
+                    "inventory_date": fields.Date.today(),
+                    "package_id": package.id if package else False,
+                }
+            )
+
+    def create_control_stock(
+        self, location, product, package=None, lot=None, name=None
+    ):
+        """Create a draft inventory so a user has to check a location
+
+        If a draft or in progress inventory already exists for the same
+        combination of product/package/lot, no inventory is created.
+        """
+        if not self._inventory_exists(location, product, package=package, lot=lot):
+            self._create_draft_inventory(location, product, package=package, lot=lot)
+
+    def create_stock_issue(self, move, location, package, lot):
+        """Create an inventory for a stock issue
+
+        It reduces the quantity in a location in a way that:
+        * assigned move lines in other batch transfers stay assigned.
+        * assigned move lines in same batch but already picked stay assigned.
+        """
+        other_lines = self._stock_issue_get_related_move_lines(
+            move, location, package, lot
+        )
+        qty_to_keep = sum(other_lines.mapped("reserved_qty"))
+        self.create_stock_correction(move, location, package, lot, qty_to_keep)
+        move._action_assign()
+
+    def create_stock_correction(self, move, location, package, lot, quantity):
+        """Create an inventory with a forced quantity"""
+        quant = self._get_existing_quant(location, move.product_id, package, lot)
+        if quant:
+            quant.with_context(
+                inventory_mode=True
+            ).sudo().inventory_quantity_auto_apply = quantity
+        else:
+            self.inventory_model._update_available_quantity(
+                move.product_id, location, quantity, lot_id=lot, package_id=package
+            )
+        # FIXME
+        move.product_id.stock_quant_ids._quant_tasks()
+
+    def _stock_issue_get_related_move_lines(self, move, location, package, lot):
+        """Lookup for all the other moves lines that match given move line"""
+        domain = [
+            ("location_id", "=", location.id),
+            ("product_id", "=", move.product_id.id),
+            ("package_id", "=", package.id),
+            ("lot_id", "=", lot.id),
+            ("state", "in", ("assigned", "partially_available")),
+        ]
+        return self.env["stock.move.line"].search(domain)
+
+    def _stock_correction_inventory_values(
+        self, move, location, package, lot, line_qty
+    ):
+        return {
+            "location_id": location.id,
+            "product_id": move.product_id.id,
+            "package_id": package.id,
+            "lot_id": lot.id,
+            "inventory_quantity": line_qty,
+        }
+
+    def _stock_issue_product_description(self, product, package, lot):
+        parts = []
+        if package:
+            parts.append(package.name)
+        parts.append(product.name)
+        if lot.name:
+            parts.append(_("Lot: ") + lot.name)
+        return " - ".join(parts)