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

odoo/addons/shopfloor/models/stock_move.py

@@ -0,0 +1,119 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2022 Jacques-Etienne Baudoux (BCIM) <je@bcim.be>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import _, models
+from odoo.tools.float_utils import float_compare
+
+
+class StockMove(models.Model):
+    _inherit = "stock.move"
+
+    def _qty_is_satisfied(self):
+        compare = float_compare(
+            self.quantity_done,
+            self.product_uom_qty,
+            precision_rounding=self.product_uom.rounding,
+        )
+        # greater or equal
+        return compare in (0, 1)
+
+    def split_other_move_lines(self, move_lines, intersection=False):
+        """Substract `move_lines` from `move.move_line_ids`, put the result
+        in a new move and returns it.
+
+        If `intersection` is set to `True`, this is the common lines between
+        `move_lines` and `move.move_line_ids` which will be put in a new move.
+        """
+        self.ensure_one()
+        other_move_lines = self.move_line_ids - move_lines
+        if intersection:
+            to_move = self.move_line_ids & move_lines
+        else:
+            to_move = other_move_lines
+        if other_move_lines or self.state == "partially_available":
+            if intersection:
+                qty_to_split = sum(to_move.mapped("reserved_uom_qty"))
+            else:
+                qty_to_split = self.product_uom_qty - sum(
+                    move_lines.mapped("reserved_uom_qty")
+                )
+            split_move_vals = self._split(qty_to_split)
+            split_move = self.create(split_move_vals)
+            split_move.move_line_ids = to_move
+            split_move._action_confirm(merge=False)
+            split_move._recompute_state()
+            split_move._action_assign()
+            self._recompute_state()
+            return split_move
+        return self.browse()
+
+    def split_unavailable_qty(self):
+        """Put unavailable qty of a partially available move in their own
+        move (which will be 'confirmed').
+        """
+        partial_moves = self.filtered(lambda m: m.state == "partially_available")
+        for partial_move in partial_moves:
+            partial_move.split_other_move_lines(partial_move.move_line_ids)
+        return partial_moves
+
+    def _extract_in_split_order(self, default=None, backorder=False):
+        """Extract moves in a new picking
+
+        :param default: dictionary of field values to override in the original
+            values of the copied record
+        :param backorder: indicate if the original picking can be seen as a
+            backorder after the split. You could apply a specific backorder
+            strategy (e.g. cancel it).
+        :return: the new order
+        """
+        picking = self.picking_id
+        picking.ensure_one()
+        data = {
+            "name": "/",
+            "move_ids": [],
+            "move_line_ids": [],
+            "backorder_id": picking.id,
+        }
+        data.update(dict(default or []))
+        new_picking = picking.copy(data)
+        link = '<a href="#" data-oe-model="stock.picking" data-oe-id="%d">%s</a>' % (
+            new_picking.id,
+            new_picking.name,
+        )
+        message = (_("The split order {} has been created.")).format(link)
+        picking.message_post(body=message)
+        self.picking_id = new_picking.id
+        self.package_level_id.picking_id = new_picking.id
+        self.move_line_ids.picking_id = new_picking.id
+        self.move_line_ids.package_level_id.picking_id = new_picking.id
+        self._action_assign()
+        return new_picking
+
+    def extract_and_action_done(self):
+        """Extract the moves in a separate transfer and validate them.
+
+        You can combine this method with `split_other_move_lines` method
+        to first extract some move lines in a separate move, then validate it
+        with this method.
+        """
+        # Process assigned moves
+        moves = self.filtered(lambda m: m.state == "assigned")
+        if not moves:
+            return False
+        new_backorders = self.env["stock.picking"]
+        for picking in moves.picking_id:
+            existing_backorders = picking.backorder_ids
+            moves_todo = picking.move_ids & moves
+            # No need to create a new transfer if we are processing all moves
+            if moves_todo == picking.move_ids:
+                new_picking = picking
+            # We process some available moves of the picking, but there are still
+            # some other moves to process, then we put the moves to process in
+            # a new transfer to validate. All remaining moves stay in the
+            # current transfer.
+            else:
+                new_picking = moves_todo._extract_in_split_order()
+                assert new_picking.state == "assigned"
+            new_picking._action_done()
+            new_backorders |= new_picking.backorder_ids - existing_backorders
+        return new_backorders

odoo/addons/shopfloor/models/stock_move_line.py

@@ -0,0 +1,307 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2022 Jacques-Etienne Baudoux (BCIM) <je@bcim.be>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+import logging
+
+from odoo import _, exceptions, fields, models
+from odoo.exceptions import UserError
+from odoo.tools.float_utils import float_compare, float_is_zero
+
+_logger = logging.getLogger(__name__)
+
+
+class StockMoveLine(models.Model):
+    _name = "stock.move.line"
+    _inherit = ["stock.move.line", "shopfloor.priority.postpone.mixin"]
+
+    # TODO use a serialized field
+    shopfloor_unloaded = fields.Boolean(default=False)
+    shopfloor_checkout_done = fields.Boolean(default=False)
+    shopfloor_user_id = fields.Many2one(comodel_name="res.users", index=True)
+
+    date_planned = fields.Datetime(related="move_id.date", store=True, index=True)
+
+    # we search lines based on their location in some workflows
+    location_id = fields.Many2one(index=True)
+    package_id = fields.Many2one(index=True)
+
+    # allow domain on picking_id.xxx without too much perf penalty
+    picking_id = fields.Many2one(auto_join=True)
+
+    def _split_partial_quantity(self):
+        """Create new move line for the quantity remaining to do
+
+        :return: the new move line if created else empty recordset
+        """
+        self.ensure_one()
+        rounding = self.product_uom_id.rounding
+        if float_is_zero(self.qty_done, precision_rounding=rounding):
+            return self.browse()
+        compare = float_compare(
+            self.qty_done, self.reserved_uom_qty, precision_rounding=rounding
+        )
+        qty_lesser = compare == -1
+        qty_greater = compare == 1
+        assert not qty_greater, "Quantity done cannot exceed quantity to do"
+        if qty_lesser:
+            remaining = self.reserved_uom_qty - self.qty_done
+            new_line = self.copy({"reserved_uom_qty": remaining, "qty_done": 0})
+            # if we didn't bypass reservation update, the quant reservation
+            # would be reduced as much as the deduced quantity, which is wrong
+            # as we only moved the quantity to a new move line
+            self.with_context(
+                bypass_reservation_update=True
+            ).reserved_uom_qty = self.qty_done
+            return new_line
+        return self.browse()
+
+    def _extract_in_split_order(self, default=None):
+        """Have pickings fully reserved with only those move lines.
+
+        If the condition is not met, extract the move lines in a new picking.
+        :param default: dictionary of field values to override in the original
+            values of the copied record
+        """
+        for picking in self.picking_id:
+            moves_to_extract = new_move = picking.move_ids.browse()
+            need_backorder = need_split = False
+            for move in picking.move_ids:
+                if move.state in ("cancel", "done"):
+                    continue
+                if move.state == "confirmed":
+                    # The move has no ancestor and is not available
+                    need_backorder = True
+                    continue
+                move_lines = move.move_line_ids & self
+                if not move_lines:
+                    # The picking contains moves not related to given move lines
+                    need_split = True
+                    continue
+                new_move = move.split_other_move_lines(move_lines, intersection=True)
+                if new_move:
+                    if move.state == "confirmed":
+                        # The move has no ancestor and is not available
+                        need_backorder = True
+                    else:
+                        # The move contains other move lines
+                        need_split = True
+                moves_to_extract += new_move or move
+            if need_split:
+                moves_to_extract._extract_in_split_order(default=default)
+            elif need_backorder:
+                # All the lines are processed but some moves are partially available
+                moves_to_extract._extract_in_split_order(
+                    default=default, backorder=True
+                )
+
+    def _split_pickings_from_source_location(self):
+        """Ensure that the related pickings will have the same source location.
+
+        Some pickings related could have other unrelated move lines, as such we
+        have to split them to contain only the move lines related to the expected
+        source location.
+
+        Example:
+
+            Initial data:
+
+                PICK1:
+                    - move line with source location LOC1
+                    - move line with source location LOC2
+                PICK2:
+                    - move line with source location LOC2
+                    - move line with source location LOC3
+
+            Then we process move lines related to LOC2 with this method, we get:
+
+                PICK1:
+                    - move line with source location LOC1
+                PICK2:
+                    - move line with source location LOC3
+                PICK3:
+                    - move line with source location LOC2
+                    - move line with source location LOC2
+
+        Return the pickings containing the given move lines.
+        """
+        _logger.warning(
+            "`_split_pickings_from_source_location` is deprecated "
+            "and replaced by `_extract_in_split_order`"
+        )
+        location_src_to_process = self.location_id
+        if location_src_to_process and len(location_src_to_process) != 1:
+            raise UserError(
+                _("Move lines processed have to share the same source location.")
+            )
+        pickings = self.picking_id
+        move_lines_to_process_ids = []
+        for picking in pickings:
+            location_src = picking.move_line_ids.location_id
+            if len(location_src) == 1:
+                continue
+            (picking.move_line_ids & self)._extract_in_split_order()
+            # Get the related move lines among the picking and split them
+            move_lines_to_process_ids.extend(
+                set(picking.move_line_ids.ids) & set(self.ids)
+            )
+        return self.picking_id
+
+    def _split_qty_to_be_done(self, qty_done, split_partial=True, **split_default_vals):
+        """Check qty to be done for current move line. Split it if needed.
+
+        :param qty_done: qty expected to be done
+        :param split_partial: split if qty is less than expected
+            otherwise rely on a backorder.
+        """
+        # store a new line if we have split our line (not enough qty)
+        new_line = self.env["stock.move.line"]
+        rounding = self.product_uom_id.rounding
+        compare = float_compare(
+            qty_done, self.reserved_uom_qty, precision_rounding=rounding
+        )
+        qty_lesser = compare == -1
+        qty_greater = compare == 1
+        if qty_greater:
+            return (new_line, "greater")
+        elif qty_lesser:
+            if not split_partial:
+                return (new_line, "lesser")
+            new_line = self._split_partial_quantity_to_be_done(
+                qty_done, split_default_vals
+            )
+            return (new_line, "lesser")
+        return (new_line, "full")
+
+    def _split_partial_quantity_to_be_done(self, quantity_done, split_default_vals):
+        """Create a new move line with the remaining quantity to process."""
+        # split the move line which will be processed later (maybe the user
+        # has to pick some goods from another place because the location
+        # contained less items than expected)
+        remaining = self.reserved_uom_qty - quantity_done
+        vals = {"reserved_uom_qty": remaining, "qty_done": 0}
+        vals.update(split_default_vals)
+        new_line = self.copy(vals)
+        # if we didn't bypass reservation update, the quant reservation
+        # would be reduced as much as the deduced quantity, which is wrong
+        # as we only moved the quantity to a new move line
+        self.with_context(
+            bypass_reservation_update=True
+        ).reserved_uom_qty = quantity_done
+        return new_line
+
+    def replace_package(self, new_package):
+        """Replace a package on an assigned move line"""
+        self.ensure_one()
+
+        # search other move lines which should already pick the scanned package
+        other_reserved_lines = self.env["stock.move.line"].search(
+            [
+                ("package_id", "=", new_package.id),
+                ("state", "in", ("partially_available", "assigned")),
+            ]
+        )
+
+        # we can't change already picked lines
+        unreservable_lines = other_reserved_lines.filtered(
+            lambda line: line.qty_done == 0
+        )
+        to_assign_moves = unreservable_lines.move_id
+
+        # if we leave the package level, it will try to reserve the same
+        # one again
+        unreservable_lines.package_level_id.explode_package()
+        # unreserve qties of other lines
+        unreservable_lines.unlink()
+
+        if new_package.location_id != self.location_id:
+            if new_package.quant_ids.reserved_quantity:
+                # this is a unexpected condition: if we started picking a package
+                # in another location, user should never be able to scan it in
+                # another location, block the operation
+                raise exceptions.UserError(
+                    _(
+                        "Package {} has been partially picked in another location"
+                    ).format(new_package.display_name)
+                )
+            # the package has been scanned in the current location so we know its
+            # a mistake in the data... fix the quant to move the package here
+            new_package.move_package_to_location(self.location_id)
+
+        # several move lines can be moved by the package level, if we change
+        # the package for the current one, we destroy the package level because
+        # we are no longer moving the entire package
+        self.package_level_id.explode_package()
+
+        def is_greater(value, other, rounding):
+            return float_compare(value, other, precision_rounding=rounding) == 1
+
+        def is_lesser(value, other, rounding):
+            return float_compare(value, other, precision_rounding=rounding) == -1
+
+        quant = fields.first(
+            new_package.quant_ids.filtered(
+                lambda quant: quant.product_id == self.product_id
+                and is_greater(
+                    quant.quantity,
+                    quant.reserved_quantity,
+                    quant.product_uom_id.rounding,
+                )
+            )
+        )
+        if not quant:
+            raise exceptions.UserError(
+                _(
+                    "Package %(package_name)s does not contain available product "
+                    "%(product_name)s, cannot replace package.",
+                    package_name=new_package.display_name,
+                    product_name=self.product_id.display_name,
+                )
+            )
+
+        values = {
+            "package_id": new_package.id,
+            "lot_id": quant.lot_id.id,
+            "owner_id": quant.owner_id.id,
+            "result_package_id": False,
+        }
+
+        available_quantity = quant.quantity - quant.reserved_quantity
+        if is_lesser(
+            available_quantity, self.reserved_qty, quant.product_uom_id.rounding
+        ):
+            new_uom_qty = self.product_id.uom_id._compute_quantity(
+                available_quantity, self.product_uom_id, rounding_method="HALF-UP"
+            )
+            values["reserved_uom_qty"] = new_uom_qty
+
+        self.write(values)
+
+        # try reassign the move in case we had a partial qty, also, it will
+        # recreate a package level if it applies
+        if "reserved_uom_qty" in values:
+            # when we change the quantity of the move, the state
+            # will still be "assigned" and be skipped by "_action_assign",
+            # recompute the state to be "partially_available"
+            self.move_id._recompute_state()
+
+        # if the new package has less quantities, assign will create new move
+        # lines
+        self.move_id._action_confirm()
+        self.move_id._action_assign()
+
+        # Find other available goods for the lines which were using the
+        # package before...
+        to_assign_moves._action_assign()
+
+        # computation of the 'state' of the package levels is not
+        # triggered, force it
+        to_assign_moves.move_line_ids.package_level_id.modified(["move_line_ids"])
+        self.package_level_id.modified(["move_line_ids"])
+
+    def _filter_on_picking(self, picking=False):
+        """Filter a bunch of lines on a picking.
+
+        If no picking is provided the first one is taken.
+        """
+        picking = picking or fields.first(self.picking_id)
+        return self.filtered_domain([("picking_id", "=", picking.id)])

odoo/addons/shopfloor/models/stock_package_level.py

@@ -0,0 +1,50 @@
+# 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, models
+
+
+class StockPackageLevel(models.Model):
+    _name = "stock.package_level"
+    _inherit = ["stock.package_level", "shopfloor.priority.postpone.mixin"]
+
+    # we search package levels based on their package in some workflows
+    package_id = fields.Many2one(index=True)
+    # allow domain on picking_id.xxx without too much perf penalty
+    picking_id = fields.Many2one(auto_join=True)
+
+    def explode_package(self):
+        """Unlink but keep the moves.
+
+        Original motivation:
+
+        A package level has a relation to "move_lines" only when the
+        package level was created first from the UI and it created
+        its move.
+        When we unlink a package level, it deletes the move it created.
+        But in some cases, we want to keep the move, e.g.:
+
+        * create a package level from the UI to move a package
+        * it generates a move for the matching product quantity
+        * we use a barcode scenario such as cluster or zone picking
+        * we use the "replace package" button
+        * when replacing the package, we have to delete the package level,
+          but we still have the same need in term of "I want X products",
+          so we have to keep the move
+        * another case is when we "dismiss" the package level in the location
+          content transfer scenario, we want to keep the "need" in moves, but
+          we are no longer moving the entire package level
+
+        Commit
+
+        https://github.com/odoo/odoo/commit/b33e72d0bf027fb2c789b1b9476f7edf1a40b0a6
+
+        introduced the handling of pkg level deletion
+        which is doing what was done by this method.
+
+        Moreover it has been fixed here https://github.com/odoo/odoo/pull/66517.
+
+        Hence, we keep this method to unify the action of "exploding a package"
+        especially to avoid to refactor many places every time the core changes.
+        """
+        # This will trigger the deletion of the pkg level
+        self.move_line_ids.result_package_id = False

odoo/addons/shopfloor/models/stock_picking.py

@@ -0,0 +1,118 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import _, api, fields, models
+
+
+class StockPicking(models.Model):
+    _inherit = "stock.picking"
+
+    total_weight = fields.Float(
+        compute="_compute_picking_info",
+        help="Technical field. Indicates total weight of transfers included.",
+    )
+    move_line_count = fields.Integer(
+        compute="_compute_picking_info",
+        help="Technical field. Indicates number of move lines included.",
+    )
+    package_level_count = fields.Integer(
+        compute="_compute_picking_info",
+        help="Technical field. Indicates number of package_level included.",
+    )
+    bulk_line_count = fields.Integer(
+        compute="_compute_picking_info",
+        help="Technical field. Indicates number of move lines without package included.",
+    )
+
+    @api.depends(
+        "move_line_ids", "move_line_ids.reserved_qty", "move_line_ids.product_id.weight"
+    )
+    def _compute_picking_info(self):
+        for item in self:
+            item.update(
+                {
+                    "total_weight": item._calc_weight(),
+                    "move_line_count": len(item.move_line_ids),
+                    "package_level_count": len(item.package_level_ids),
+                    # NOTE: not based on 'move_line_ids_without_package' field
+                    # on purpose as it also takes into account the
+                    # 'Move entire packs' option from the picking type.
+                    "bulk_line_count": len(
+                        item.move_line_ids.filtered(lambda ml: not ml.package_level_id)
+                    ),
+                }
+            )
+
+    def _calc_weight(self):
+        weight = 0.0
+        for move_line in self.mapped("move_line_ids"):
+            weight += move_line.reserved_qty * move_line.product_id.weight
+        return weight
+
+    def _check_move_lines_map_quant_package(self, package):
+        # see tests/test_move_action_assign.py for details
+        pack_move_lines = self.move_line_ids.filtered(
+            lambda ml: ml.package_id == package
+        )
+        # if we set a qty_done on any line, it's picked, we don't want
+        # to change it in any case, so we ignore the package level
+        if any(pack_move_lines.mapped("qty_done")):
+            return False
+        # if we already changed the destination package, do not create
+        # a new package level
+        if any(
+            line.result_package_id != package
+            for line in pack_move_lines
+            if line.result_package_id
+        ):
+            return False
+        return super()._check_move_lines_map_quant_package(package)
+
+    def split_assigned_move_lines(self, move_lines=None):
+        """Put all reserved quantities (move lines) in their own moves and transfer.
+
+        As a result, the current transfer will contain only confirmed moves.
+        """
+        self.ensure_one()
+        # Check in the picking all the moves which are partially available or confirmed
+        moves = self.move_lines.filtered(
+            lambda m: m.state in ("partially_available", "confirmed")
+        )
+        # If one of these moves has an ancestor, split the moves
+        # then extract all the assigned moves in a new transfer.
+        # Indeed, a move without ancestor won't see its reserved qty changed
+        # automatically over time.
+        has_ancestors = bool(
+            moves.move_orig_ids.filtered(lambda m: m.state not in ("cancel", "done"))
+        )
+        if not has_ancestors:
+            return self.id
+        # Get only transfers composed of moves assigned or confirmed
+        moves.split_other_move_lines(moves.move_line_ids)
+        # Put assigned moves related to processed move lines into a separate transfer
+        if move_lines:
+            assigned_moves = self.move_lines & move_lines.move_id
+        else:
+            assigned_moves = self.move_lines.filtered(lambda m: m.state == "assigned")
+        if assigned_moves == self.move_lines:
+            return self.id
+        new_picking = self.copy(
+            {
+                "name": "/",
+                "move_lines": [],
+                "move_line_ids": [],
+                "backorder_id": self.id,
+            }
+        )
+        message = _(
+            'The backorder <a href="#" '
+            'data-oe-model="stock.picking" '
+            'data-oe-id="%(new_picking_id)d">%(new_picking_name)s</a> has been created.'
+        ) % dict(new_picking_id=new_picking.id, new_picking_name=new_picking.name)
+        self.message_post(body=message)
+        assigned_moves.write({"picking_id": new_picking.id})
+        assigned_moves.mapped("move_line_ids").write({"picking_id": new_picking.id})
+        assigned_moves.move_line_ids.package_level_id.write(
+            {"picking_id": new_picking.id}
+        )
+        assigned_moves._action_assign()
+        return new_picking.id

odoo/addons/shopfloor/models/stock_picking_batch.py

@@ -0,0 +1,41 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import api, fields, models
+
+
+class StockPickingBatch(models.Model):
+    _inherit = "stock.picking.batch"
+
+    picking_count = fields.Integer(
+        compute="_compute_picking_info",
+        help="Technical field. Indicates number of transfers included.",
+    )
+    move_line_count = fields.Integer(
+        compute="_compute_picking_info",
+        help="Technical field. Indicates number of move lines included.",
+    )
+    total_weight = fields.Float(
+        compute="_compute_picking_info",
+        help="Technical field. Indicates total weight of transfers included.",
+    )
+
+    @api.depends(
+        "picking_ids.state", "picking_ids.total_weight", "picking_ids.move_line_ids"
+    )
+    def _compute_picking_info(self):
+        for item in self:
+            assigned_pickings = item.picking_ids.filtered(
+                lambda picking: picking.state == "assigned"
+            )
+            item.update(
+                {
+                    "picking_count": len(assigned_pickings.ids),
+                    "move_line_count": len(
+                        assigned_pickings.mapped("move_line_ids").ids
+                    ),
+                    "total_weight": item._calc_weight(assigned_pickings),
+                }
+            )
+
+    def _calc_weight(self, pickings):
+        return sum(pickings.mapped("total_weight"))

odoo/addons/shopfloor/models/stock_picking_type.py

@@ -0,0 +1,26 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import api, fields, models
+
+
+class StockPickingType(models.Model):
+    _inherit = "stock.picking.type"
+
+    shopfloor_menu_ids = fields.Many2many(
+        comodel_name="shopfloor.menu",
+        string="Shopfloor Menus",
+        readonly=True,
+    )
+    shopfloor_zero_check = fields.Boolean(
+        string="Activate Zero Check",
+        help="For Shopfloor scenarios using it (Cluster Picking, Zone Picking,"
+        " Discrete order Picking), the zero check step will be activated when"
+        " a location becomes empty after a move.",
+    )
+
+    @api.constrains("show_entire_packs")
+    def _check_move_entire_packages(self):
+        menu_items = self.env["shopfloor.menu"].search(
+            [("picking_type_ids", "in", self.ids)]
+        )
+        menu_items._check_move_entire_packages()