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

odoo/addons/shopfloor/actions/search.py

@@ -0,0 +1,187 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo.osv.expression import AND
+
+from odoo.addons.component.core import Component
+
+
+class SearchResult:
+
+    __slots__ = ("record", "type", "code")
+
+    def __init__(self, **kw) -> None:
+        for k in self.__slots__:
+            setattr(self, k, kw.get(k))
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: type={self.type} code={self.code}>"
+
+    def __bool__(self):
+        return self.type != "none" or bool(self.record)
+
+    def __eq__(self, other):
+        for k in self.__slots__:
+            if not hasattr(other, k):
+                return False
+            if getattr(other, k) != getattr(self, k):
+                return False
+        return True
+
+    @property
+    def records(self):
+        """In some cases we expect more than one records (eg: location limit > 1) or lots"""
+        return self.record if len(self.record) > 1 else None
+
+
+class SearchAction(Component):
+    """Provide methods to search records from scanner
+
+    The methods should be used in Service Components, so a search will always
+    have the same result in all scenarios.
+    """
+
+    _inherit = "shopfloor.search.action"
+
+    @property
+    def _barcode_type_handler(self):
+        return {
+            "product": self.product_from_scan,
+            "package": self.package_from_scan,
+            "picking": self.picking_from_scan,
+            "location": self.location_from_scan,
+            "location_dest": self.location_from_scan,
+            "lot": self.lot_from_scan,
+            "serial": self.lot_from_scan,
+            "packaging": self.packaging_from_scan,
+            "delivery_packaging": self.delivery_packaging_from_scan,
+            "origin_move": self.origin_move_from_scan,
+        }
+
+    def _make_search_result(self, **kwargs):
+        """Build a 'SearchResult' object describing the record found.
+
+        If no record has been found, the SearchResult object will have
+        its 'type' defined to "none".
+        """
+        return SearchResult(**kwargs)
+
+    def find(self, barcode, types=None, handler_kw=None):
+        """Find Odoo record matching given `barcode`.
+
+        Plain barcodes
+        """
+        barcode = barcode or ""
+        return self.generic_find(barcode, types=types, handler_kw=handler_kw)
+
+    def generic_find(self, barcode, types=None, handler_kw=None):
+        handler_kw = handler_kw or {}
+        _types = types or self._barcode_type_handler.keys()
+        # TODO: decide the best default order in case we don't pass `types`
+        for btype in _types:
+            handler = self._barcode_type_handler.get(btype)
+            if not handler:
+                continue
+            record = handler(barcode, **handler_kw.get(btype, {}))
+            if record:
+                return self._make_search_result(record=record, code=barcode, type=btype)
+
+        return self._make_search_result(type="none")
+
+    def location_from_scan(self, barcode, limit=1):
+        model = self.env["stock.location"]
+        if not barcode:
+            return model.browse()
+        # First search location by barcode
+        res = model.search([("barcode", "=", barcode)], limit=limit)
+        # And only if we have not found through barcode search on the location name
+        if len(res) < limit:
+            res |= model.search([("name", "=", barcode)], limit=(limit - len(res)))
+        return res
+
+    def package_from_scan(self, barcode):
+        model = self.env["stock.quant.package"]
+        if not barcode:
+            return model.browse()
+        return model.search([("name", "=", barcode)], limit=1)
+
+    def picking_from_scan(self, barcode, use_origin=False):
+        model = self.env["stock.picking"]
+        if not barcode:
+            return model.browse()
+        picking = model.search([("name", "=", barcode)], limit=1)
+        # We need to split the domain in two different searches
+        # as there might be a case where
+        # the name of a picking is the same as the origin of another picking
+        # (e.g. in a backorder) and we need to make sure
+        # the name search takes priority.
+        if picking:
+            return picking
+        if use_origin:
+            source_document_domain = [
+                # We could have the same origin for multiple transfers
+                # but we're interested only in the "assigned" ones.
+                ("origin", "=", barcode),
+                ("state", "=", "assigned"),
+            ]
+            return model.search(source_document_domain)
+        return model.browse()
+
+    def product_from_scan(self, barcode):
+        model = self.env["product.product"]
+        if not barcode:
+            return model.browse()
+        return model.search(
+            [
+                "|",
+                ("barcode", "=", barcode),
+                ("default_code", "=", barcode),
+            ],
+            limit=1,
+        )
+
+    def lot_from_scan(self, barcode, products=None, limit=1):
+        model = self.env["stock.lot"]
+        if not barcode:
+            return model.browse()
+        domain = [
+            ("company_id", "=", self.env.company.id),
+            ("name", "=", barcode),
+        ]
+        if products:
+            domain.append(("product_id", "in", products.ids))
+        return model.search(domain, limit=limit)
+
+    def packaging_from_scan(self, barcode):
+        model = self.env["product.packaging"]
+        if not barcode:
+            return model.browse()
+        return model.search(
+            [("barcode", "=", barcode), ("product_id", "!=", False)], limit=1
+        )
+
+    def generic_packaging_from_scan(self, barcode):
+        model = self.env["product.packaging"]
+        if not barcode:
+            return model.browse()
+        return model.search(
+            [("barcode", "=", barcode), ("product_id", "=", False)], limit=1
+        )
+
+    def delivery_packaging_from_scan(self, barcode):
+        model = self.env["stock.package.type"]
+        if not barcode:
+            return model.browse()
+        return model.search([("barcode", "=", barcode)], limit=1)
+
+    def origin_move_from_scan(self, barcode, extra_domain=None):
+        model = self.env["stock.move"]
+        outgoing_move_domain = [
+            # We could have the same origin for multiple transfers
+            # but we're interested only in the "done" ones.
+            ("origin", "=", barcode),
+            ("state", "=", "done"),
+        ]
+        if extra_domain:
+            outgoing_move_domain = AND([outgoing_move_domain, extra_domain])
+        return model.search(outgoing_move_domain)

odoo/addons/shopfloor/actions/stock.py

@@ -0,0 +1,239 @@
+# 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.tools.float_utils import float_round
+
+from odoo.addons.component.core import Component
+
+from ..exceptions import ConcurentWorkOnTransfer
+
+
+class StockAction(Component):
+    """Provide methods to work with stock operations."""
+
+    _name = "shopfloor.stock.action"
+    _inherit = "shopfloor.process.action"
+    _usage = "stock"
+
+    def _create_return_move__get_max_qty(self, origin_move):
+        """Returns the max returneable qty."""
+        # The max returnable qty is the sent qty minus the already returned qties
+        quantity = origin_move.reserved_qty
+        for move in origin_move.move_dest_ids:
+            if (
+                move.origin_returned_move_id
+                and move.origin_returned_move_id != origin_move
+            ):
+                continue
+            if move.state in ("partially_available", "assigned"):
+                quantity -= sum(move.move_line_ids.mapped("reserved_qty"))
+            elif move.state in ("done"):
+                quantity -= move.reserved_qty
+        return float_round(
+            quantity, precision_rounding=origin_move.product_id.uom_id.rounding
+        )
+
+    def _create_return_move__get_vals(self, return_picking, origin_move):
+        product = origin_move.product_id
+        return_type = return_picking.picking_type_id
+        return {
+            "product_id": product.id,
+            "product_uom": product.uom_id.id,
+            "picking_id": return_picking.id,
+            "state": "draft",
+            "date": fields.Datetime.now(),
+            "location_id": return_picking.location_id.id,
+            "location_dest_id": return_picking.location_dest_id.id,
+            "picking_type_id": return_type.id,
+            "warehouse_id": return_type.warehouse_id.id,
+            "origin_returned_move_id": origin_move.id,
+            "procure_method": "make_to_stock",
+        }
+
+    def _create_return_move__link_to_origin(self, return_move, origin_move):
+        move_orig_to_link = origin_move.move_dest_ids.mapped("returned_move_ids")
+        move_orig_to_link |= origin_move
+        origin_move_dest = origin_move.move_dest_ids.filtered(
+            lambda m: m.state not in ("cancel")
+        )
+        move_orig_to_link |= origin_move_dest.move_orig_ids.filtered(
+            lambda m: m.state not in ("cancel")
+        )
+        move_dest_to_link = origin_move.move_orig_ids.mapped("returned_move_ids")
+        move_dest_orig = origin_move.returned_move_ids.move_orig_ids.filtered(
+            lambda m: m.state not in ("cancel")
+        )
+        move_dest_to_link |= move_dest_orig.move_dest_ids.filtered(
+            lambda m: m.state not in ("cancel")
+        )
+        write_vals = {
+            "move_orig_ids": [(4, m.id) for m in move_orig_to_link],
+            "move_dest_ids": [(4, m.id) for m in move_dest_to_link],
+        }
+        return_move.write(write_vals)
+
+    def create_return_move(self, return_picking, origin_moves):
+        """Creates a return move for a given return picking / move"""
+        # Logic has been copied from
+        # odoo_src/addons/stock/wizard/stock_picking_return.py
+        for origin_move in origin_moves:
+            # If max qty <= 0, it means that everything has been returned already.
+            # Try with the next one from the recordset.
+            max_qty = self._create_return_move__get_max_qty(origin_move)
+            if max_qty > 0:
+                return_move_vals = self._create_return_move__get_vals(
+                    return_picking, origin_move
+                )
+                return_move_vals.update(product_uom_qty=max_qty)
+                return_move = origin_move.copy(return_move_vals)
+                self._create_return_move__link_to_origin(return_move, origin_move)
+                return return_move
+
+    def _create_return_picking__get_vals(self, return_types, origin):
+        return_type = fields.first(return_types)
+        return {
+            "move_lines": [],
+            "picking_type_id": return_type.id,
+            "state": "draft",
+            "origin": origin,
+            "location_id": return_type.default_location_src_id.id,
+            "location_dest_id": return_type.default_location_dest_id.id,
+            "is_shopfloor_created": True,
+        }
+
+    def create_return_picking(self, picking, return_types, origin):
+        # Logic has been copied from
+        # odoo_src/addons/stock/wizard/stock_picking_return.py
+        return_values = self._create_return_picking__get_vals(return_types, origin)
+        return picking.copy(return_values)
+
+    def mark_move_line_as_picked(
+        self, move_lines, quantity=None, package=None, user=None, check_user=False
+    ):
+        """Set the qty_done and extract lines in new order"""
+        user = user or self.env.user
+        if check_user:
+            picking_users = move_lines.picking_id.user_id
+            if not all(pick_user == user for pick_user in picking_users):
+                raise ConcurentWorkOnTransfer(
+                    _("Someone is already working on these transfers")
+                )
+        for line in move_lines:
+            qty_done = quantity if quantity is not None else line.reserved_uom_qty
+            line.qty_done = qty_done
+            line._split_partial_quantity()
+            data = {
+                "shopfloor_user_id": user.id,
+            }
+            if package:
+                # destination package is set to the scanned one
+                data["result_package_id"] = package.id
+            line.write(data)
+        # Extract the picked quantity in a split order and set current user
+        move_lines._extract_in_split_order(
+            {
+                "user_id": user.id,
+                "printed": True,
+            }
+        )
+        move_lines.picking_id.filtered(lambda p: p.user_id != user).user_id = user.id
+
+    def unmark_move_line_as_picked(self, move_lines):
+        """Reverse the change from `mark_move_line_as_picked`."""
+        move_lines.write(
+            {
+                "shopfloor_user_id": False,
+                "qty_done": 0,
+                "result_package_id": False,
+            }
+        )
+        pickings = move_lines.picking_id
+        for picking in pickings:
+            lines_still_assigned = picking.move_line_ids.filtered(
+                lambda l: l.shopfloor_user_id
+            )
+            if lines_still_assigned:
+                # Because there is other lines in the picking still assigned
+                # The picking has to be split
+                unmark_lines = picking.move_line_ids & move_lines
+                unmark_lines._extract_in_split_order(default={"user_id": False})
+            else:
+                pickings.write(
+                    {
+                        "user_id": False,
+                        "printed": False,
+                    }
+                )
+
+    def validate_moves(self, moves):
+        """Validate moves in different ways depending on several criterias:
+
+        - moves to process are all the moves of the related transfer:
+            the current transfer is validated
+        - moves to process are a subset of available moves in the picking:
+            the moves are put in a new transfer which is validated, the current
+            transfer still have the remaining moves
+        - moves to process are exactly the assigned moves of the related transfer:
+            the transfer is validated as usual, creating a backorder.
+        """
+        moves.split_unavailable_qty()
+        backorders = self.env["stock.picking"]
+        for picking in moves.picking_id:
+            # the backorder strategy is checked in the 'button_validate' method
+            # on odoo standard. Since we call the sub-method '_action_done' here,
+            # we have to set the context key 'cancel_backorder' as it is done
+            # in the 'button_validate' method according to the backorder strategy.
+            not_to_backorder = picking.picking_type_id.create_backorder == "never"
+            picking = picking.with_context(cancel_backorder=not_to_backorder)
+            moves_todo = picking.move_ids & moves
+            if self._check_backorder(picking, moves_todo):
+                existing_backorders = picking.backorder_ids
+                picking._action_done()
+                new_backorders = picking.backorder_ids - existing_backorders
+                if new_backorders:
+                    new_backorders.write({"user_id": False})
+                backorders |= new_backorders
+            else:
+                backorders |= moves_todo.extract_and_action_done()
+        return backorders
+
+    def _check_backorder(self, picking, moves):
+        """Check if the `picking` has to be validated as usual to create a backorder.
+
+        We want to create a normal backorder if:
+
+            - the moves are equal to all available moves of the current picking
+              but there are still unavailable moves to process
+            - the moves are not linked to unprocessed ancestor moves
+        """
+        assigned_moves = picking.move_ids.filtered(lambda m: m.state == "assigned")
+        has_ancestors = bool(
+            moves.move_orig_ids.filtered(lambda m: m.state not in ("cancel", "done"))
+        )
+        return moves == assigned_moves and not has_ancestors
+
+    def put_package_level_in_move(self, package_level):
+        """Ensure to put the package level in its own move.
+
+        In standard the moves linked to a package level could also be linked to
+        other unrelated move lines. This method ensures that the package level
+        will be attached to a move with only the relevant lines.
+        This is useful to process a single package, having its own move makes
+        this process easy.
+        """
+        package_move_lines = package_level.move_line_ids
+        package_moves = package_move_lines.move_id
+        for package_move in package_moves:
+            # Check if there is no other lines linked to the move others than
+            # the lines related to the package itself. In such case we have to
+            # split the move to process only the lines related to the package.
+            package_move.split_other_move_lines(package_move_lines)
+
+    def no_putaway_available(self, picking_types, move_lines):
+        """Returns `True` if no putaway destination has been computed for one
+        of the given move lines.
+        """
+        base_locations = picking_types.default_location_dest_id
+        # when no putaway is found, the move line destination stays the
+        # default's of the picking type
+        return any(line.location_dest_id in base_locations for line in move_lines)

odoo/addons/shopfloor/actions/stock_unreserve.py

@@ -0,0 +1,66 @@
+# Copyright 2022 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+from odoo.addons.component.core import Component
+
+
+class StockUnreserve(Component):
+    """Provide methods to unreserve goods of a location."""
+
+    _name = "shopfloor.stock.unreserve.action"
+    _inherit = "shopfloor.process.action"
+    _usage = "stock.unreserve"
+
+    def check_unreserve(self, location, move_lines, product=None, lot=None):
+        """Return a message if there is an ongoing operation in the location.
+
+        It could be a move line with some qty already processed or another
+        Shopfloor user working there.
+
+        :param location: stock location from which moves are unreserved
+        :param move_lines: move lines to unreserve
+        :param product: optional product to limit the scope in the location
+        """
+        location_move_lines = self._find_location_all_move_lines(location, product, lot)
+        extra_move_lines = location_move_lines - move_lines
+        if extra_move_lines:
+            return self.msg_store.picking_already_started_in_location(
+                extra_move_lines.picking_id
+            )
+
+    def unreserve_moves(self, move_lines, picking_types):
+        """Unreserve moves from `move_lines'.
+
+        Returns a tuple of (
+          move lines that stays in the location to process,
+          moves to reserve again
+        )
+        """
+        moves_to_unreserve = move_lines.move_id
+        # If there is no other moves to unreserve of a different picking type, leave
+        lines_other_picking_types = move_lines.filtered(
+            lambda line: line.picking_id.picking_type_id not in picking_types
+        )
+        if not lines_other_picking_types:
+            return (move_lines, self.env["stock.move"].browse())
+        # if we leave the package level around, it will try to reserve
+        # the same package as before
+        package_levels = move_lines.package_level_id
+        package_levels.explode_package()
+        moves_to_unreserve._do_unreserve()
+        return (move_lines - lines_other_picking_types, moves_to_unreserve)
+
+    def _find_location_all_move_lines_domain(self, location, product=None, lot=None):
+        domain = [
+            ("location_id", "=", location.id),
+            ("state", "in", ("assigned", "partially_available")),
+        ]
+        if product:
+            domain.append(("product_id", "=", product.id))
+        if lot:
+            domain.append(("lot_id", "=", lot.id))
+        return domain
+
+    def _find_location_all_move_lines(self, location, product=None, lot=None):
+        return self.env["stock.move.line"].search(
+            self._find_location_all_move_lines_domain(location, product, lot)
+        )

odoo/addons/shopfloor/components/__init__.py

@@ -0,0 +1,5 @@
+from . import scan_handler_location
+from . import scan_handler_package
+from . import scan_handler_product
+from . import scan_handler_lot
+from . import scan_handler_transfer

odoo/addons/shopfloor/components/scan_handler_location.py

@@ -0,0 +1,26 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2021 ACSONE SA/NV (http://www.acsone.eu)
+# @author Simone Orsi <simahawk@gmail.com>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo.addons.component.core import Component
+
+
+class LocationHandler(Component):
+    """Scan anything handler for stock.location."""
+
+    _name = "shopfloor.scan.location.handler"
+    _inherit = "shopfloor.scan.anything.handler"
+
+    record_type = "location"
+
+    def search(self, identifier):
+        res = self._search.find(identifier, types=("location",))
+        return res.record if res.record else self.env["stock.location"]
+
+    @property
+    def converter(self):
+        return self._data_detail.location_detail
+
+    def schema(self):
+        return self._schema_detail.location_detail()

odoo/addons/shopfloor/components/scan_handler_lot.py

@@ -0,0 +1,26 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2021 ACSONE SA/NV (http://www.acsone.eu)
+# @author Simone Orsi <simahawk@gmail.com>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo.addons.component.core import Component
+
+
+class LotHandler(Component):
+    """Scan anything handler for stock.lot."""
+
+    _name = "shopfloor.scan.lot.handler"
+    _inherit = "shopfloor.scan.anything.handler"
+
+    record_type = "lot"
+
+    def search(self, identifier):
+        res = self._search.find(identifier, types=("lot",))
+        return res.record if res.record else self.env["stock.lot"]
+
+    @property
+    def converter(self):
+        return self._data_detail.lot_detail
+
+    def schema(self):
+        return self._schema_detail.lot_detail()

odoo/addons/shopfloor/components/scan_handler_package.py

@@ -0,0 +1,26 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2021 ACSONE SA/NV (http://www.acsone.eu)
+# @author Simone Orsi <simahawk@gmail.com>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo.addons.component.core import Component
+
+
+class PackageHandler(Component):
+    """Scan anything handler for stock.quant.package."""
+
+    _name = "shopfloor.scan.package.handler"
+    _inherit = "shopfloor.scan.anything.handler"
+
+    record_type = "package"
+
+    def search(self, identifier):
+        res = self._search.find(identifier, types=("package",))
+        return res.record if res.record else self.env["stock.quant.package"]
+
+    @property
+    def converter(self):
+        return self._data_detail.package_detail
+
+    def schema(self):
+        return self._schema_detail.package_detail()

odoo/addons/shopfloor/components/scan_handler_product.py

@@ -0,0 +1,26 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2021 ACSONE SA/NV (http://www.acsone.eu)
+# @author Simone Orsi <simahawk@gmail.com>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo.addons.component.core import Component
+
+
+class ProductHandler(Component):
+    """Scan anything handler for product.product."""
+
+    _name = "shopfloor.scan.product.handler"
+    _inherit = "shopfloor.scan.anything.handler"
+
+    record_type = "product"
+
+    def search(self, identifier):
+        res = self._search.find(identifier, types=("product", "packaging"))
+        return res.record if res.record else self.env["product.product"]
+
+    @property
+    def converter(self):
+        return self._data_detail.product_detail
+
+    def schema(self):
+        return self._schema_detail.product_detail()

odoo/addons/shopfloor/components/scan_handler_transfer.py

@@ -0,0 +1,26 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2021 ACSONE SA/NV (http://www.acsone.eu)
+# @author Simone Orsi <simahawk@gmail.com>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo.addons.component.core import Component
+
+
+class TransferHandler(Component):
+    """Scan anything handler for stock.picking."""
+
+    _name = "shopfloor.scan.transfer.handler"
+    _inherit = "shopfloor.scan.anything.handler"
+
+    record_type = "transfer"
+
+    def search(self, identifier):
+        res = self._search.find(identifier, types=("picking",))
+        return res.record if res.record else self.env["stock.picking"]
+
+    @property
+    def converter(self):
+        return self._data_detail.picking_detail
+
+    def schema(self):
+        return self._schema_detail.picking_detail()