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

odoo/addons/shopfloor/services/menu.py

@@ -0,0 +1,60 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo.addons.base_rest.components.service import to_int
+from odoo.addons.component.core import Component
+
+
+class ShopfloorMenu(Component):
+    _inherit = "shopfloor.service.menu"
+
+    def _convert_one_record(self, record):
+        values = super()._convert_one_record(record)
+        if record.picking_type_ids:
+            counters = self._get_move_line_counters(record)
+            values.update(counters)
+        return values
+
+    def _get_move_line_counters(self, record):
+        """Lookup for all lines per menu item and compute counters."""
+        # TODO: maybe to be improved w/ raw SQL as this run for each menu item
+        # and it's called every time the menu is opened/gets refreshed
+        move_line_search = self._actions_for(
+            "search_move_line", picking_types=record.picking_type_ids
+        )
+        locations = record.picking_type_ids.mapped("default_location_src_id")
+        lines_per_menu = move_line_search.search_move_lines_by_location(locations)
+        return move_line_search.counters_for_lines(lines_per_menu)
+
+    def _one_record_parser(self, record):
+        parser = super()._one_record_parser(record)
+        if not record.picking_type_ids:
+            return parser
+        return parser + [
+            ("picking_type_ids:picking_types", ["id", "name"]),
+        ]
+
+
+class ShopfloorMenuValidatorResponse(Component):
+    """Validators for the Menu endpoints responses"""
+
+    _inherit = "shopfloor.service.menu.validator.response"
+
+    @property
+    def _record_schema(self):
+        schema = super()._record_schema
+        schema.update(
+            {
+                "picking_types": self.schemas._schema_list_of(
+                    self._picking_type_schema, required=False, nullable=True
+                )
+            }
+        )
+        schema.update(self.schemas.move_lines_counters())
+        return schema
+
+    @property
+    def _picking_type_schema(self):
+        return {
+            "id": {"coerce": to_int, "required": True, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": True},
+        }

odoo/addons/shopfloor/services/picking_batch.py

@@ -0,0 +1,126 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo.osv import expression
+
+from odoo.addons.component.core import Component
+
+
+class PickingBatch(Component):
+    """Picking Batch services for the client application."""
+
+    _inherit = "base.shopfloor.service"
+    _name = "shopfloor.picking.batch"
+    _usage = "picking_batch"
+    _expose_model = "stock.picking.batch"
+    _description = __doc__
+
+    def _get_base_search_domain(self):
+        base_domain = super()._get_base_search_domain()
+        user = self.env.user
+        return expression.AND(
+            [
+                base_domain,
+                [
+                    "|",
+                    "&",
+                    ("user_id", "=", False),
+                    ("state", "=", "draft"),
+                    "&",
+                    ("user_id", "=", user.id),
+                    ("state", "in", ("draft", "in_progress")),
+                ],
+            ]
+        )
+
+    def _search(self, name_fragment=None, batch_ids=None):
+        domain = self._get_base_search_domain()
+        if name_fragment:
+            domain = expression.AND([domain, [("name", "ilike", name_fragment)]])
+        if batch_ids:
+            domain = expression.AND([domain, [("id", "in", batch_ids)]])
+        records = self.env[self._expose_model].search(domain, order="id asc")
+        records = records.filtered(
+            # Include done/cancel because we want to be able to work on the
+            # batch even if some pickings are done/canceled. They'll should be
+            # ignored later.
+            lambda batch: all(
+                (
+                    # When the batch is already in progress, we do not care
+                    # about state of the pickings, because we want to be able
+                    # to recover it in any case, even if, for instance, a stock
+                    # error changed a picking to unavailable after the user
+                    # started to work on the batch.
+                    batch.state == "in_progress"
+                    or picking.state in ("assigned", "done", "cancel")
+                )
+                and picking.picking_type_id in self.picking_types
+                for picking in batch.picking_ids
+            )
+        )
+        return records
+
+    def search(self, name_fragment=None):
+        """List available stock picking batches for current user
+
+        Show only picking batches where all the pickings are available and
+        where all pickings are in the picking type of the current scenario.
+        """
+        records = self._search(name_fragment=name_fragment)
+        return self._response(
+            data={"size": len(records), "records": self._to_json(records)}
+        )
+
+    def _convert_one_record(self, record):
+        assigned_pickings = record.picking_ids.filtered(
+            lambda picking: picking.state == "assigned"
+        )
+        return {
+            "id": record.id,
+            "name": record.name,
+            "picking_count": len(assigned_pickings),
+            "move_line_count": len(assigned_pickings.mapped("move_line_ids")),
+            "weight": record.total_weight(),
+        }
+
+
+class ShopfloorPickingBatchValidator(Component):
+    """Validators for the Picking_Batch endpoints"""
+
+    _inherit = "base.shopfloor.validator"
+    _name = "shopfloor.picking.batch.validator"
+    _usage = "picking_batch.validator"
+
+    def search(self):
+        return {
+            "name_fragment": {"type": "string", "nullable": True, "required": False}
+        }
+
+
+class ShopfloorPickingBatchValidatorResponse(Component):
+    """Validators for the Picking_Batch endpoints responses"""
+
+    _inherit = "base.shopfloor.validator.response"
+    _name = "shopfloor.picking.batch.validator.response"
+    _usage = "picking_batch.validator.response"
+
+    def search(self):
+        return self._response_schema(
+            {
+                "size": {"required": True, "type": "integer"},
+                "records": {
+                    "type": "list",
+                    "required": True,
+                    "schema": {"type": "dict", "schema": self._record_schema},
+                },
+            }
+        )
+
+    @property
+    def _record_schema(self):
+        return {
+            "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"},
+        }

odoo/addons/shopfloor/services/service.py

@@ -0,0 +1,101 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2020 Akretion (http://www.akretion.com)
+# Copyright 2020-2021 Jacques-Etienne Baudoux (BCIM) <je@bcim.be>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import _, exceptions
+
+from odoo.addons.component.core import AbstractComponent
+
+
+class BaseShopfloorService(AbstractComponent):
+    """Base class for REST services"""
+
+    _inherit = "base.shopfloor.service"
+
+    @property
+    def search_move_line(self):
+        # TODO: propagating `picking_types` should probably be default
+        return self._actions_for("search_move_line", propagate_kwargs=["picking_types"])
+
+
+class BaseShopfloorProcess(AbstractComponent):
+
+    _inherit = "base.shopfloor.process"
+
+    def _get_process_picking_types(self):
+        """Return picking types for the menu"""
+        return self.work.menu.picking_type_ids
+
+    @property
+    def picking_types(self):
+        if not hasattr(self.work, "picking_types"):
+            self.work.picking_types = self._get_process_picking_types()
+        if not self.work.picking_types:
+            raise exceptions.UserError(
+                _("No operation types configured on menu {}.").format(
+                    self.work.menu.name
+                )
+            )
+        return self.work.picking_types
+
+    @property
+    def search_move_line(self):
+        # TODO: picking types should be set somehow straight in the work context
+        # by `_validate_headers_update_work_context` in this way
+        # we can remove this override and the need to call `_get_process_picking_types`
+        # every time.
+        return self._actions_for("search_move_line", picking_types=self.picking_types)
+
+    def _check_picking_status(self, pickings, states=("assigned",)):
+        """Check if given pickings can be processed.
+
+        If the picking is already done, canceled or didn't belong to the
+        expected picking type, a message is returned.
+        """
+        for picking in pickings:
+            if not picking.exists():
+                return self.msg_store.stock_picking_not_found()
+            if picking.state == "done":
+                return self.msg_store.already_done()
+            if picking.state not in states:  # the picking must be ready
+                return self.msg_store.stock_picking_not_available(picking)
+            if picking.picking_type_id not in self.picking_types:
+                return self.msg_store.cannot_move_something_in_picking_type()
+
+    def is_src_location_valid(self, location):
+        """Check the source location is valid for given process.
+
+        We ensure the source is valid regarding one of the picking types of the
+        process.
+        """
+        return location.is_sublocation_of(self.picking_types.default_location_src_id)
+
+    def is_dest_location_valid(self, moves, location):
+        """Check the destination location is valid for given moves.
+
+        We ensure the destination is either valid regarding the picking
+        destination location or the move destination location. With the push
+        rules in the module stock_dynamic_routing in OCA/wms, it is possible
+        that the move destination is not anymore a child of the picking default
+        destination (as it is the last pushed move that now respects this
+        condition and not anymore this one that has a destination to an
+        intermediate location)
+        """
+        return location.is_sublocation_of(
+            moves.picking_id.location_dest_id, func=all
+        ) or location.is_sublocation_of(moves.location_dest_id, func=all)
+
+    def is_dest_location_to_confirm(self, location_dest_id, location):
+        """Check the destination location requires confirmation
+
+        The location is valid but not the expected one: ask for confirmation
+        """
+        return not location.is_sublocation_of(location_dest_id)
+
+    def is_allow_move_create(self):
+        """Check a new operation can be created
+
+        The menu is configured to allow the creation of moves
+        The menu is bind to one picking type
+        """
+        return self.work.menu.allow_move_create and len(self.picking_types) == 1

odoo/addons/shopfloor/services/single_pack_transfer.py

@@ -0,0 +1,366 @@
+# Copyright 2020-2021 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2020-2021 Jacques-Etienne Baudoux (BCIM) <je@bcim.be>
+# Copyright 2020 Akretion (http://www.akretion.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import fields
+
+from odoo.addons.base_rest.components.service import to_int
+from odoo.addons.component.core import Component
+
+
+class SinglePackTransfer(Component):
+    """Methods for the Single Pack Transfer Process
+
+    You will find a sequence diagram describing states and endpoints
+    relationships [here](../docs/single_pack_transfer_diag_seq.png).
+    Keep [the sequence diagram](../docs/single_pack_transfer_diag_seq.plantuml)
+    up-to-date if you change endpoints.
+    """
+
+    _inherit = "base.shopfloor.process"
+    _name = "shopfloor.single.pack.transfer"
+    _usage = "single_pack_transfer"
+    _description = __doc__
+
+    def _data_after_package_scanned(self, package_level):
+        move_lines = package_level.move_line_ids
+        package = package_level.package_id
+        # TODO use data.package_level (but the "name" moves in "package.name")
+        return {
+            "id": package_level.id,
+            "name": package.name,
+            "location_src": self.data.location(package.location_id),
+            "location_dest": self.data.location(package_level.location_dest_id),
+            "products": self.data.products(move_lines.product_id),
+            "picking": self.data.picking(move_lines.picking_id),
+        }
+
+    def _response_for_start(self, message=None, popup=None):
+        return self._response(next_state="start", message=message, popup=popup)
+
+    def _response_for_confirm_start(self, package_level, message=None):
+        data = self._data_after_package_scanned(package_level)
+        data["confirmation_required"] = True
+        return self._response(
+            next_state="start",
+            data=data,
+            message=message,
+        )
+
+    def _response_for_scan_location(
+        self, package_level, message=None, confirmation_required=False
+    ):
+        data = self._data_after_package_scanned(package_level)
+        data["confirmation_required"] = confirmation_required
+        return self._response(
+            next_state="scan_location",
+            data=data,
+            message=message,
+        )
+
+    def _scan_source(self, barcode, confirmation=False):
+        """Search a package"""
+        search = self._actions_for("search")
+        location = search.location_from_scan(barcode)
+
+        package = self.env["stock.quant.package"]
+        if location:
+            package = self.env["stock.quant.package"].search(
+                [("location_id", "=", location.id)]
+            )
+            if not package:
+                return (self.msg_store.no_pack_in_location(location), None)
+            if len(package) > 1:
+                return (self.msg_store.several_packs_in_location(location), None)
+
+        if not package:
+            package = search.package_from_scan(barcode)
+
+        if not package:
+            return (self.msg_store.package_not_found_for_barcode(barcode), None)
+        if not package.location_id:
+            return (self.msg_store.package_has_no_product_to_take(barcode), None)
+        if not self.is_src_location_valid(package.location_id):
+            return (
+                self.msg_store.package_not_allowed_in_src_location(
+                    barcode, self.picking_types
+                ),
+                None,
+            )
+
+        return (None, package)
+
+    def start(self, barcode, confirmation=False):
+        picking_types = self.picking_types
+        message, package = self._scan_source(barcode, confirmation)
+        if message:
+            return self._response_for_start(message=message)
+        package_level = self.env["stock.package_level"].search(
+            [
+                ("package_id", "=", package.id),
+                ("picking_id.picking_type_id", "in", picking_types.ids),
+            ]
+        )
+
+        # Start a savepoint because we are may unreserve moves of other
+        # picking types. If we do and we can't create a package level after,
+        # we rollback to the initial state
+        savepoint = self._actions_for("savepoint").new()
+        unreserved_moves = self.env["stock.move"].browse()
+        if not package_level:
+            other_move_lines = self.env["stock.move.line"].search(
+                [
+                    ("package_id", "=", package.id),
+                    # to exclude canceled and done
+                    ("state", "in", ("assigned", "partially_available")),
+                ]
+            )
+            if any(line.qty_done > 0 for line in other_move_lines) or (
+                other_move_lines and not self.work.menu.allow_unreserve_other_moves
+            ):
+                picking = fields.first(other_move_lines).picking_id
+                return self._response_for_start(
+                    message=self.msg_store.package_already_picked_by(package, picking)
+                )
+            elif other_move_lines and self.work.menu.allow_unreserve_other_moves:
+
+                unreserved_moves = other_move_lines.move_id
+                other_package_levels = other_move_lines.package_level_id
+                other_package_levels.explode_package()
+                unreserved_moves._do_unreserve()
+
+        # State is computed, can't use it in the domain. And it's probably faster
+        # to filter here rather than using a domain on "picking_id.state" that would
+        # use a sub-search on stock.picking: we shouldn't have dozens of package levels
+        # for a package.
+        package_level = package_level.filtered(
+            lambda pl: pl.state not in ("cancel", "done", "draft")
+        )
+        message = self.msg_store.no_pending_operation_for_pack(package)
+        if not package_level and self.is_allow_move_create():
+            package_level = self._create_package_level(package)
+            if not self.is_dest_location_valid(
+                package_level.move_line_ids.move_id, package_level.location_dest_id
+            ):
+                package_level = None
+                savepoint.rollback()
+                message = self.msg_store.package_unable_to_transfer(package)
+
+        if not package_level:
+            # restore any unreserved move/package level
+            savepoint.rollback()
+            return self._response_for_start(message=message)
+        stock = self._actions_for("stock")
+        if self.work.menu.ignore_no_putaway_available and stock.no_putaway_available(
+            self.picking_types, package_level.move_line_ids
+        ):
+            # the putaway created a move line but no putaway was possible, so revert
+            # to the initial state
+            savepoint.rollback()
+            return self._response_for_start(
+                message=self.msg_store.no_putaway_destination_available()
+            )
+
+        if package_level.is_done and not confirmation:
+            return self._response_for_confirm_start(
+                package_level, message=self.msg_store.already_running_ask_confirmation()
+            )
+        if not package_level.is_done:
+            package_level.is_done = True
+
+        unreserved_moves._action_assign()
+
+        savepoint.release()
+
+        return self._response_for_scan_location(package_level)
+
+    def _create_package_level(self, package):
+        # this method can be called only if we have one picking type
+        # (allow_move_create==True on menu)
+        assert self.picking_types.ensure_one()
+        StockPicking = self.env["stock.picking"].with_context(
+            default_picking_type_id=self.picking_types.id
+        )
+        picking = StockPicking.create({})
+        package_level = self.env["stock.package_level"].create(
+            {
+                "picking_id": picking.id,
+                "package_id": package.id,
+                "location_dest_id": picking.location_dest_id.id,
+                "company_id": self.env.company.id,
+            }
+        )
+        picking.action_confirm()
+        picking.action_assign()
+        # For packages that contain several products (so linked to several
+        # moves), the putaway destination computation of the strategy
+        # triggered by `action_assign()` above won't work, so we trigger
+        # the computation manually here at the package level.
+        package_level.recompute_pack_putaway()
+        return package_level
+
+    def _is_move_state_valid(self, moves):
+        return all(move.state != "cancel" for move in moves)
+
+    def validate(self, package_level_id, location_barcode, confirmation=False):
+        """Validate the transfer"""
+        search = self._actions_for("search")
+
+        package_level = self.env["stock.package_level"].browse(package_level_id)
+        if not package_level.exists():
+            return self._response_for_start(
+                message=self.msg_store.operation_not_found()
+            )
+
+        # Do not use package_level.move_lines, this is only filled in when the
+        # moves have been created from a manually encoded package level, not
+        # when a package has been reserved for existing moves
+        moves = package_level.move_line_ids.move_id
+        if not self._is_move_state_valid(moves):
+            return self._response_for_start(
+                message=self.msg_store.operation_has_been_canceled_elsewhere()
+            )
+
+        scanned_location = search.location_from_scan(location_barcode)
+        if not scanned_location:
+            return self._response_for_scan_location(
+                package_level, message=self.msg_store.no_location_found()
+            )
+
+        if not self.is_dest_location_valid(moves, scanned_location):
+            return self._response_for_scan_location(
+                package_level, message=self.msg_store.dest_location_not_allowed()
+            )
+
+        if not confirmation and self.is_dest_location_to_confirm(
+            package_level.location_dest_id, scanned_location
+        ):
+            return self._response_for_scan_location(
+                package_level,
+                confirmation_required=True,
+                message=self.msg_store.confirm_location_changed(
+                    package_level.location_dest_id, scanned_location
+                ),
+            )
+
+        self._set_destination_and_done(package_level, scanned_location)
+        return self._router_validate_success(package_level)
+
+    def _is_last_move(self, move):
+        return move.picking_id.completion_info == "next_picking_ready"
+
+    def _router_validate_success(self, package_level):
+        move = package_level.move_line_ids.move_id
+
+        message = self.msg_store.confirm_pack_moved()
+
+        completion_info_popup = None
+        if self._is_last_move(move):
+            completion_info = self._actions_for("completion.info")
+            completion_info_popup = completion_info.popup(package_level.move_line_ids)
+        return self._response_for_start(message=message, popup=completion_info_popup)
+
+    def _set_destination_and_done(self, package_level, scanned_location):
+        # when writing the destination on the package level, it writes
+        # on the move lines
+        package_level.location_dest_id = scanned_location
+        stock = self._actions_for("stock")
+        stock.put_package_level_in_move(package_level)
+        stock.validate_moves(package_level.move_line_ids.move_id)
+
+    def cancel(self, package_level_id):
+        package_level = self.env["stock.package_level"].browse(package_level_id)
+        if not package_level.exists():
+            return self._response_for_start(
+                message=self.msg_store.operation_not_found()
+            )
+        # package.move_lines may be empty, it seems
+        moves = package_level.move_ids | package_level.move_line_ids.move_id
+        if "done" in moves.mapped("state"):
+            return self._response_for_start(message=self.msg_store.already_done())
+
+        package_level.is_done = False
+        return self._response_for_start(
+            message=self.msg_store.confirm_canceled_scan_next_pack()
+        )
+
+
+class SinglePackTransferValidator(Component):
+    """Validators for Single Pack Transfer methods"""
+
+    _inherit = "base.shopfloor.validator"
+    _name = "shopfloor.single.pack.transfer.validator"
+    _usage = "single_pack_transfer.validator"
+
+    def start(self):
+        return {
+            "barcode": {"type": "string", "nullable": False, "required": True},
+            "confirmation": {"type": "boolean", "required": False},
+        }
+
+    def cancel(self):
+        return {
+            "package_level_id": {"coerce": to_int, "required": True, "type": "integer"}
+        }
+
+    def validate(self):
+        return {
+            "package_level_id": {"coerce": to_int, "required": True, "type": "integer"},
+            "location_barcode": {"type": "string", "nullable": False, "required": True},
+            "confirmation": {"type": "boolean", "required": False},
+        }
+
+
+class SinglePackTransferValidatorResponse(Component):
+    """Validators for Single Pack Transfer methods responses"""
+
+    _inherit = "base.shopfloor.validator.response"
+    _name = "shopfloor.single.pack.transfer.validator.response"
+    _usage = "single_pack_transfer.validator.response"
+
+    def _states(self):
+        """List of possible next states
+
+        With the schema of the data send to the client to transition
+        to the next state.
+        """
+        schema_for_start = self._schema_for_package_level_details()
+        schema_for_start.update(self._schema_confirmation_required())
+        schema_for_scan_location = self._schema_for_package_level_details(required=True)
+        schema_for_scan_location.update(self._schema_confirmation_required())
+        return {
+            "start": schema_for_start,
+            "scan_location": schema_for_scan_location,
+        }
+
+    def start(self):
+        return self._response_schema(next_states={"start", "scan_location"})
+
+    def cancel(self):
+        return self._response_schema(next_states={"start"})
+
+    def validate(self):
+        return self._response_schema(next_states={"scan_location", "start"})
+
+    def _schema_for_package_level_details(self, required=False):
+        # TODO use schemas.package_level (but the "name" moves in "package.name")
+        return {
+            "id": {"required": required, "type": "integer"},
+            "name": {"type": "string", "nullable": False, "required": required},
+            "location_src": {"type": "dict", "schema": self.schemas.location()},
+            "location_dest": {"type": "dict", "schema": self.schemas.location()},
+            "products": {
+                "type": "list",
+                "schema": {"type": "dict", "schema": self.schemas.product()},
+            },
+            "picking": {"type": "dict", "schema": self.schemas.picking()},
+        }
+
+    def _schema_confirmation_required(self):
+        return {
+            "confirmation_required": {
+                "type": "boolean",
+                "nullable": True,
+                "required": False,
+            },
+        }