diff --git a/addons/point_of_sale/views/point_of_sale_dashboard.xml b/addons/point_of_sale/views/point_of_sale_dashboard.xml index f3b3d973add..bbf9301168e 100644 --- a/addons/point_of_sale/views/point_of_sale_dashboard.xml +++ b/addons/point_of_sale/views/point_of_sale_dashboard.xml @@ -71,7 +71,7 @@
-
+
@@ -103,7 +103,7 @@
-
+
diff --git a/addons/pos_self_order/__manifest__.py b/addons/pos_self_order/__manifest__.py index 79f187de5bc..713db7c505d 100644 --- a/addons/pos_self_order/__manifest__.py +++ b/addons/pos_self_order/__manifest__.py @@ -1,60 +1,57 @@ # -*- coding: utf-8 -*- { - 'name': "POS Self Order", - - 'summary': """ + "name": "POS Self Order", + "summary": """ Addon for the POS App that allows customers to view the menu on their smartphone. """, - - 'category': 'Sales/Point Of Sale', - - 'depends': ['pos_restaurant', 'http_routing'], - 'auto_install': ['pos_restaurant'], - - 'demo': [ - 'demo/pos_restaurant_demo.xml', + "category": "Sales/Point Of Sale", + "depends": ["pos_restaurant", "http_routing"], + "auto_install": ["pos_restaurant"], + "demo": [ + "demo/pos_restaurant_demo.xml", ], - 'data': [ - 'security/ir.model.access.csv', - 'views/index.xml', - 'views/qr_code.xml', - 'views/custom_link_views.xml', - 'data/custom_link_data.xml', - 'views/res_config_settings_views.xml', - 'views/point_of_sale_dashboard.xml', + "data": [ + "security/ir.model.access.csv", + "views/index.xml", + "views/qr_code.xml", + "views/custom_link_views.xml", + "data/custom_link_data.xml", + "data/restaurant_table_data.xml", + "views/res_config_settings_views.xml", + "views/point_of_sale_dashboard.xml", ], - 'assets': { - 'pos_self_order.assets_self_order': [ - ('include', 'web._assets_helpers'), - ('include', 'web._assets_backend_helpers'), - ('include', 'web._assets_primary_variables'), - 'web/static/src/scss/pre_variables.scss', - 'web/static/lib/bootstrap/scss/_functions.scss', - 'web/static/lib/bootstrap/scss/_variables.scss', - ('include', 'web._assets_bootstrap'), - 'web/static/src/boot.js', - 'web/static/src/env.js', - 'web/static/src/session.js', - 'web/static/src/core/utils/transitions.scss', - 'web/static/src/core/**/*', - 'web/static/lib/owl/owl.js', - 'web/static/lib/owl/odoo_module.js', - 'web/static/lib/luxon/luxon.js', - - 'web/static/src/views/fields/formatters.js', - 'web/static/src/libs/fontawesome/css/font-awesome.css', - 'web/static/lib/odoo_ui_icons/*', - - 'pos_self_order/static/src/**/*', - 'point_of_sale/static/src/utils.js', + "assets": { + "pos_self_order.assets_self_order": [ + ("include", "web._assets_helpers"), + ("include", "web._assets_backend_helpers"), + ("include", "web._assets_primary_variables"), + "web/static/src/scss/pre_variables.scss", + "web/static/lib/bootstrap/scss/_functions.scss", + "web/static/lib/bootstrap/scss/_variables.scss", + ("include", "web._assets_bootstrap"), + ("include", "web._assets_bootstrap_backend"), + "web/static/src/boot.js", + "web/static/src/env.js", + "web/static/src/session.js", + "web/static/src/core/utils/transitions.scss", + "web/static/src/core/**/*", + "web/static/lib/owl/owl.js", + "web/static/lib/owl/odoo_module.js", + "web/static/lib/luxon/luxon.js", + "web/static/src/views/fields/formatters.js", + "web/static/src/libs/fontawesome/css/font-awesome.css", + "web/static/lib/odoo_ui_icons/*", + "pos_self_order/static/src/**/*", + "point_of_sale/static/src/utils.js", ], - 'pos_self_order.assets_tests': [ - 'web/static/lib/jquery/jquery.js', - 'web/static/lib/underscore/underscore.js', - 'web_tour/static/src/tour_pointer/**/*.js', - 'web_tour/static/src/tour_service/**/*.js', - 'pos_self_order/static/tests/tours/**/*', + "pos_self_order.assets_tests": [ + "web/static/lib/jquery/jquery.js", + "web/static/lib/underscore/underscore.js", + "web_tour/static/src/tour_pointer/**/*.xml", + "web_tour/static/src/tour_pointer/**/*.js", + "web_tour/static/src/tour_service/**/*", + "pos_self_order/static/tests/tours/**/*", ], }, - 'license': 'LGPL-3', + "license": "LGPL-3", } diff --git a/addons/pos_self_order/controllers/__init__.py b/addons/pos_self_order/controllers/__init__.py index b0f26a9a602..7d91bf1afc7 100644 --- a/addons/pos_self_order/controllers/__init__.py +++ b/addons/pos_self_order/controllers/__init__.py @@ -1,3 +1,4 @@ # -*- coding: utf-8 -*- -from . import controllers +from . import qr_menu +from . import ordering diff --git a/addons/pos_self_order/controllers/controllers.py b/addons/pos_self_order/controllers/controllers.py deleted file mode 100644 index 9adb2c6f106..00000000000 --- a/addons/pos_self_order/controllers/controllers.py +++ /dev/null @@ -1,199 +0,0 @@ -# -*- coding: utf-8 -*- - -from typing import List, Dict, Optional -import werkzeug - -from odoo import http -from odoo.http import request - -from odoo.addons.http_routing.models.ir_http import unslug -from odoo.addons.point_of_sale.models.product import ProductProduct -from odoo.addons.pos_self_order.models.pos_config import PosConfig - - -class PosSelfOrderController(http.Controller): - """ - This is the controller for the POS Self Order App - There is one main route that the client will use to access the POS Self Order App: /menu - This route will render the LANDING PAGE of the POS Self Order App - And it will pass the needed data to the template: the list of products, pos_config_id, table_id, company_name, currency... - After that the client will be able to navigate to the /products route w/o aditional requests - to the server, using client side routing. - """ - - @http.route("/menu", auth="public") - def pos_self_order_redirect(self): - pos_config_id = self._get_any_pos_config_with_qr_code_menu_sudo().id - return request.redirect(f"/menu/{pos_config_id}") - - @http.route( - [ - "/menu/", - "/menu//products", - "/menu//products/", - ], - auth="public", - website=True, - sitemap=True - ) - def pos_self_order_start(self, pos_name: str): - """ - The user gets this route from the QR code that they scan at the table - :param pos_name: the name of the pos config: can be the id or the slugified name of the pos config - :return: the rendered template - """ - _, pos_config_id = unslug(pos_name) - pos_config_sudo = self._get_pos_config_sudo(pos_config_id) - session_info = request.env["ir.http"].get_frontend_session_info() - session_info.update({ - "currencies": request.env["ir.http"].get_currencies(), - "pos_self_order": self._get_self_order_config(pos_config_sudo), - }) - response = request.render("pos_self_order.index", {"session_info": session_info}) - return response - - @http.route( - [ - "/menu/get-image/", - "/menu/get-image//", - ], - methods=["GET"], - type="http", - auth="public", - ) - def pos_self_order_get_image(self, product_id: int, image_size: Optional[int] = None): - """ - This is the route that the POS Self Order App uses to GET THE PRODUCT IMAGES - :return: the image of the product - :rtype: binary - """, - # The idea here is to not show the image if there is no pos with the self order menu - if not self._get_any_pos_config_with_qr_code_menu_sudo(): - raise werkzeug.exceptions.NotFound() - - product_sudo = request.env["product.product"].sudo().browse(product_id) - if not product_sudo.available_in_pos: - raise werkzeug.exceptions.NotFound() - - if image_size == 1920 and product_sudo.image_1920: - return ( - request.env["ir.binary"] - ._get_image_stream_from(product_sudo, field_name="image_1920") - .get_response() - ) - return ( - request.env["ir.binary"] - ._get_image_stream_from(product_sudo, field_name="image_128") - .get_response() - ) - - @http.route("/menu/get-bg-image", methods=["GET"], type="http", auth="public") - def pos_self_order_get_bg_image(self, pos_config_id: int): - """ - Gets the background image for this self order - :return: the bg image - :rtype: binary - """, - pos_config_sudo = self._get_pos_config_sudo(pos_config_id) - if not pos_config_sudo.self_order_image: - raise werkzeug.exceptions.NotFound() - return ( - request.env["ir.binary"] - ._get_image_stream_from(pos_config_sudo, field_name="self_order_image") - .get_response() - ) - - def _get_any_pos_config_with_qr_code_menu_sudo(self) -> PosConfig: - """ - Returns a PosConfig that allows the QR code menu, if there is one, - or raises a NotFound otherwise - """ - pos_config_sudo = ( - request.env["pos.config"] - .sudo() - .search([("self_order_view_mode", "=", True)], limit=1) - ) - if not pos_config_sudo: - raise werkzeug.exceptions.NotFound() - return pos_config_sudo - - def _get_pos_config_sudo(self, pos_config_id: int) -> PosConfig: - """ - Returns the PosConfig if pos_config_id exist and the pos is configured to allow the menu to be viewed online. - If not, it raises a NotFound - """ - pos_config_sudo = request.env["pos.config"].sudo().browse( - int(pos_config_id)) - if not pos_config_sudo or not pos_config_sudo.self_order_view_mode: - raise werkzeug.exceptions.NotFound() - return pos_config_sudo - - def _get_self_order_config(self, pos_config_sudo: PosConfig) -> Dict: - """ - Returns the necessary information for the POS Self Order App - """ - return { - "pos_config_id": pos_config_sudo.id, - "company_name": pos_config_sudo.company_id.name, - "currency_id": pos_config_sudo.currency_id.id, - "show_prices_with_tax_included": pos_config_sudo.iface_tax_included == "total", - "custom_links": self._get_custom_links(pos_config_sudo.id), - "attributes_by_ptal_id": request.env["pos.session"].sudo()._get_attributes_by_ptal_id(), - "products": self._get_data_from_products(self._get_available_products_sudo(pos_config_sudo.id), pos_config_sudo.id), - } - - def _get_custom_links(self, pos_config_id: int) -> List[Dict[str, str]]: - """ - On the landing page of the app we can have a number of custom links - that are defined by the restaurant employee in the backend. - This function returns a list of dictionaries with the attributes of each link - that is available for the POS with id pos_config_id. - """ - domain = [ - "|", - ("pos_config_ids", "in", [pos_config_id]), - ("pos_config_ids", "=", False), - ] - return ( - request.env["pos_self_order.custom_link"] - .sudo() - .search_read(domain, fields=["name", "url", "style"], order="sequence") - ) - - def _get_available_products_sudo(self, pos_config_id: int) -> ProductProduct: - """ - This function returns the products that are available in the POS with id pos_config_id - """ - domain = [("available_in_pos", "=", True)] - pos_config_sudo = self._get_pos_config_sudo(pos_config_id) - if (pos_config_sudo.limit_categories and pos_config_sudo.iface_available_categ_ids): - domain.append(("pos_categ_id", "in", pos_config_sudo.iface_available_categ_ids.ids)) - return ( - request.env["product.product"] - .sudo() - .search(domain, order="pos_categ_id.sequence asc nulls last") - ) - - def _get_data_from_products(self, products_sudo: ProductProduct, pos_config_id: int) -> List[Dict[str, str]]: - """ - This function adds the price info to each product in the list products_sudo - and returns the list of products with the necessary info - """ - return [ - { - "price_info": product.get_product_info_pos( - product.lst_price, 1, int(pos_config_id) - )["all_prices"], - "has_image": bool(product.image_1920), - **product.read( - [ - "id", - "display_name", - "description_sale", - "pos_categ_id", - "attribute_line_ids", - ] - )[0], - } - for product in products_sudo - ] diff --git a/addons/pos_self_order/controllers/ordering.py b/addons/pos_self_order/controllers/ordering.py new file mode 100644 index 00000000000..e7b22143adf --- /dev/null +++ b/addons/pos_self_order/controllers/ordering.py @@ -0,0 +1,464 @@ +# -*- coding: utf-8 -*- + +from typing import List, Dict, Optional, Union +import werkzeug +import uuid + +from odoo import http, fields +from odoo.http import request +from odoo.tools import partition + + +from odoo.addons.pos_self_order.controllers.utils import ( + get_pos_config_sudo, + get_table_sudo, +) +from odoo.addons.pos_self_order.models.product_product import ProductProduct +from odoo.addons.pos_self_order.models.pos_order import PosOrder, PosOrderLine +from odoo.addons.pos_self_order.models.pos_config import PosConfig + + +class PosSelfOrderController(http.Controller): + @http.route( + "/pos-self-order/send-order", + auth="public", + type="json", + website=True, + ) + def pos_self_order_send_order( + self, + cart: List[Dict], + pos_config_id: int, + table_access_token: Optional[str] = None, + order_pos_reference: Optional[str] = None, + order_access_token: Optional[str] = None, + ) -> Dict[str, str]: + """ + There are 2 types of self order configurations: + 1. Order at table and pay after each order + ==> pos doesn't allow ongoing orders + 2. Order at table and pay at the end of the meal + ==> pos allows ongoing orders + (order at table means order from personal device (smartphone)) + In case 1. we will create a new order each time the user sends an order + In case 2. we will create a new order only if the user does not have an ongoing order + (we will look whether there is an order with state = 'draft' + with the same pos_reference and order_access_token as the ones that the user has provided) + :param cart: order lines + :param pos_config_id: the id of the POS where the order is being sent + :param table_access_token: the access token of the table where the order is being sent (UUID v4) + :param pos_reference: the id of the order that is being edited; ex: "Order 00001-001-0001" + :param order_access_token: the access token of the order that is being edited (UUID v4) + :return: dictionary with keys: pos_reference, order_access_token + """ + # we will only respond with the order "access_token" and "id". After clicking on the `Order` button, + # the customer will be redirected to the landing page. + # From the `landing page`, the customer can go to the `My Orders` page. + # on this page, the app will automatically make a request to the `view-order` route, + # so the customer will get the order details that way + + pos_config_sudo = get_pos_config_sudo(pos_config_id) + + if not pos_config_sudo.self_order_table_mode or not pos_config_sudo.has_active_session: + raise werkzeug.exceptions.BadRequest() + + order = self._form_order( + self._create_order_data( + cart, + pos_config_sudo, + table_access_token, + order_pos_reference, + order_access_token, + ) + ) + posted_order_id = ( + request.env["pos.order"] + .sudo() + .create_from_ui( + [order], + draft=True, + )[0] + .get("id") + ) + + return ( + request.env["pos.order"] + .sudo() + .browse(posted_order_id) + .read(["pos_reference", "access_token"])[0] + ) + + # # is_trusted is set to True by default. + # # We need to set it to False, because we are creating an order from a public route + # # FIXME: make it so we only set it to false if it is a new order + # # if the server already acknowledged the order, we should not set it to false again + # # every time the user adds a new item to the order + # request.env["pos.order"].sudo().browse(order_resp.get("id")).is_trusted = False + + @http.route("/pos-self-order/view-order", auth="public", type="json", website=True) + def pos_self_order_view_order(self, pos_reference: str, access_token: str) -> Dict: + """ + Return some information about a given order. + This is used by the frontend to find the latest state of an order. + (e.g. if a customer orders something from the self order app and then the waiter adds an item to the order, + the customer will be able to see the new item in the order) + :param pos_reference: the id of the order that we want to view + :param access_token: the access token of the order that we want to view -- this is needed + for security reasons, so that only the customer who created the order + can view it + """ + order_sudo = self._find_order(pos_reference, access_token) + if not order_sudo: + raise werkzeug.exceptions.Unauthorized() + return order_sudo._export_for_self_order() + + def _create_order_data( + self, + cart: List[Dict], + pos_config_sudo: PosConfig, + table_access_token: Optional[str], + order_pos_reference: Optional[str], + order_access_token: Optional[str], + ) -> Dict[str, Union[int, str, List[Dict]]]: + """ + Given the data, we decide whether we need to create a new order or update an existing one + :return: dictionary with the data needed to create a new order + """ + + # We only care about the previous order if the customer is paying after the meal + # ( paying after the meal means that the customer can order multiple times on the same order ) + order_sudo = pos_config_sudo.self_order_pay_after == "meal" and self._find_order( + order_pos_reference, order_access_token, state="draft" + ) + + return { + **( + order_sudo._get_self_order_data() + if order_sudo + else self._create_new_order_data(pos_config_sudo, table_access_token) + ), + "lines": self._create_orderlines( + self._merge_orderlines( + cart, order_sudo.lines.export_for_ui(), order_sudo.config_id + ) + if order_sudo + else cart, + pos_config_sudo, + ), + } + + def _create_new_order_data( + self, pos_config_sudo: PosConfig, table_access_token: str + ) -> Dict[str, Union[str, int]]: + """ + :param pos_config_id: the id of the pos config for which we want to create the order + :param table_access_token: the access token of the table for which we want to create the order + :return: a dictionary containing the data that we need to create a new order + """ + table_sudo = get_table_sudo(table_access_token) + pos_session_sudo = pos_config_sudo.current_session_id + if not table_sudo or not pos_session_sudo: + raise werkzeug.exceptions.Unauthorized() + + sequence_number = self._get_sequence_number(table_sudo.id, pos_session_sudo.id) + + return { + "id": self._generate_unique_id(pos_session_sudo.id, table_sudo.id, sequence_number), + "sequence_number": sequence_number, + "access_token": uuid.uuid4().hex, + "session_id": pos_session_sudo.id, + "table_id": table_sudo.id, + } + + def _merge_orderlines( + self, + incoming_orderlines: List[Dict], + existing_orderlines: List[Dict], + pos_config_sudo: PosConfig, + ) -> List[Dict]: + """ + If the customer has an existing order, we will add the items from the existing order to the current cart. + (This is because the create_from_ui method will overwrite the old items from the order) + :param cart: The cart from the frontend. + :return: list of dictionaries with the items from the cart and the items from the existing order + """ + has_merge_candidate = lambda item: self._has_merge_candidate(item, existing_orderlines) + + orderlines_to_be_merged, orderlines_to_be_appended = partition( + has_merge_candidate, incoming_orderlines + ) + + return ( + self._get_updated_orderlines( + existing_orderlines, orderlines_to_be_merged, pos_config_sudo + ) + + orderlines_to_be_appended + ) + + def _has_merge_candidate(self, item: Dict, existing_orderlines: List[Dict]) -> bool: + return any(self._can_be_merged(item, line) for line in existing_orderlines) + + def _can_be_merged(self, orderline1, orderline2): + return self._is_pos_groupable(orderline1["product_id"]) and all( + orderline1.get(key, "") == orderline2.get(key, "") + for key in PosOrderLine._get_unique_keys() + ) + + def _get_updated_orderlines( + self, orderlines: List[Dict], cart: List[Dict], pos_config_sudo: PosConfig + ) -> List[Dict]: + """ + :returns updated version of orderlines that takes into account the new items from the cart + """ + return [ + self._get_updated_orderline(line, updated_item, pos_config_sudo) + if ( + updated_item := next( + (item for item in cart if self._can_be_merged(item, line)), None + ) + ) + else line + for line in orderlines + ] + + def _get_updated_orderline( + self, line: Dict, updated_item: Dict, pos_config_sudo: PosConfig + ) -> Dict: + """ + This function assumes that the price of the product was not changed between the time the + first items were added to the order and the time the new items were added to the order. + """ + new_qty = updated_item["qty"] + line["qty"] + new_price = ( + request.env["product.product"] + .sudo() + .browse(int(line["product_id"])) + ._get_price_info(pos_config_sudo, qty=new_qty) + ) + return { + **line, + **{ + "price_subtotal": new_price["price_without_tax"], + "price_subtotal_incl": new_price["price_with_tax"], + "qty": new_qty, + "customer_note": updated_item.get("customer_note") or line.get("customer_note"), + }, + } + + def _is_pos_groupable(self, product_id: int) -> bool: + return ( + request.env["product.product"].sudo().browse(int(product_id)).uom_id.is_pos_groupable + ) + + def _get_full_product_name(self, name: str, description: str) -> str: + """ + :param name: ex: "[E-COM12] Desk Organizer" + :param description: ex: "M, Leather" + :return: ex: "Desk Organizer (M, Leather)" + """ + return f"{name} ({description})" if description else name + + def _create_orderlines(self, cart: List[Dict], pos_config_sudo: PosConfig) -> List[Dict]: + """ + Function that constructs the order lines (as the create_from_ui method expects them) from the cart. + From the frontend we only get basic data of the cart, such as the id of the product and the quantity. + We need to get the other details of the product from the database. + This is done for security reasons. + """ + + return [ + [ + 0, + 0, + self._create_orderline( + item, + pos_config_sudo, + ), + ] + # having the "full product name" means that the orderline is already in the db + # so we don't need to create a new object + if not item.get("full_product_name") else [0, 0, item] + for item in cart + ] + + def _create_orderline(self, item: Dict, pos_config_sudo: PosConfig) -> Dict: + """ + Function that constructs an order line (as the create_from_ui method expects it) from an item from the cart. + """ + product_sudo = request.env["product.product"].sudo().browse(int(item.get("product_id"))) + return { + "product_id": item.get("product_id"), + "qty": item.get("qty"), + **self._get_orderline_price_info(product_sudo, item, pos_config_sudo), + "discount": 0, + "tax_ids": product_sudo.taxes_id, + "pack_lot_ids": [], + "description": item.get("description"), # ex "M, Leather" + "full_product_name": self._get_full_product_name( # ex: "Desk Organizer (M, Leather)" + product_sudo._get_name(), + item.get("description"), + ), + "customer_note": item.get("customer_note"), + "price_manually_set": False, + "note": "", + "uuid": str(uuid.uuid4()), + } + + def _get_orderline_price_info( + self, product_sudo: ProductProduct, item: Dict, pos_config_sudo: PosConfig + ) -> Dict: + price_extra = ( + self._compute_price_extra(product_sudo, item.get("description"), pos_config_sudo) + if item.get("description") + else 0 + ) + price_unit = product_sudo.lst_price + price_extra + price_subtotal_info = product_sudo._get_price_info( + pos_config_sudo, price_unit, item.get("qty") + ) + + return { + "price_unit": price_unit, + "price_subtotal": price_subtotal_info["price_without_tax"], + "price_subtotal_incl": price_subtotal_info["price_with_tax"], + "price_extra": price_extra, + } + + def _compute_price_extra( + self, product_sudo: ProductProduct, description: str, pos_config_sudo: PosConfig + ) -> float: + """ + Function that computes the price_extra of a product based on the description. + :param description: The description of the product. ex: "M, Leather" + represents the selected values of the product's attributes. + """ + + return sum( + v["price_extra"]["price_without_tax"] + for attr, selected_value_name in zip( + product_sudo._get_attributes(pos_config_sudo), description.split(", ") + ) + for v in attr["values"] + if v["name"] == selected_value_name + ) + + def _form_order(self, order: Dict) -> Dict: + """ + Function that constructs an order object (as the create_from_ui method expects it) + It takes as input the order object that was created by self._create_order_data() + :param order: Dictionary representing an order. + :return: Dictionary representing an order (as the create_from_ui method expects it). + """ + # The self order can only update an order that was created on the self order itself. + # This is because the self order does not have the ability to update orders that were created on the POS, + # because the app wouldn't know the access token of the order. + + return { + "id": order.get("id"), + "data": { + "name": order.get("id"), + "amount_paid": 0, + "amount_total": self._compute_amount_total(order.get("lines")), + "amount_tax": self._compute_amount_tax(order.get("lines")), + "amount_return": 0, + "lines": order.get("lines"), + "statement_ids": [], + "pos_session_id": order.get("session_id"), + "partner_id": False, + "user_id": request.session.uid, + # we only need the digits of the pos_reference, not the whole id, which starts with word "Order" + "uid": order.get("id")[6:], + "sequence_number": order.get("sequence_number"), + "creation_date": str(fields.Datetime.now()), + "fiscal_position_id": False, + "to_invoice": False, + "to_ship": False, + "is_tipped": False, + "tip_amount": 0, + "access_token": order.get("access_token"), + "server_id": False, + "table_id": order.get("table_id"), + }, + "to_invoice": False, + "session_id": order.get("session_id"), + } + + def _compute_amount_total(self, lines: List[Dict]) -> float: + return sum(orderline[2].get("price_subtotal_incl") for orderline in lines) + + def _compute_amount_tax(self, lines: List[Dict]) -> float: + return sum( + orderline[2].get("price_subtotal_incl") - orderline[2].get("price_subtotal") + for orderline in lines + ) + + # the 2nd argument of pos_reference is the login number; + # the regular pos receives the login number from the backend on the first load + # the problem is that if the pos has login number 1, for example + # and we create a new order in the database, with sequence number 1, for example, + # when the regular pos will try to create a new order, it will also use sequence number 1 + # and login number 1 and the new order will have the same id as the order created by the self order app + # so it will ultimately not be recorded in the database. + # ( the regular pos does not check what was the last order id from the database ) + # it keeps track itself of the last order id -- this is why this problem occurs + # I thought that it is best to make the pos_self_order app work around + # the problem, instead of modifying the regular pos. + # so I decided to use the numbers from 900 to 999 for the login number + # this way, the regular pos will have a login number of 1, 2, 3, etc + # and the pos_self_order app will have a login number of 901, 902, 903, etc, + # where 901 is the login number of the table with id = 1, + # 902 is the login number of the table with id = 2, etc + # TODO: make it so the regular pos can't have a login number of 900 or more + # FIXME: what happens if `table_id` is larger that 100? + # [possible fix: using a different pos session for the self order an synchronizing the orders] + def _generate_unique_id(self, pos_session_id: int, table_id: int, sequence_number: int) -> str: + """ + Generates a public identification number for the order. + :return: The order name. Example: Order 00001-001-0001 + """ + return f"Order {pos_session_id:0>5}-{900 + table_id :0>3}-{sequence_number:0>4}" + + def _find_order( + self, + pos_reference: Optional[str], + order_access_token: Optional[str], + state: Optional[str] = None, + ) -> PosOrder: + """ + :return: pos order with the given pos_reference, access token and state + """ + return ( + pos_reference + and order_access_token + and request.env["pos.order"] + .sudo() + .search( + [ + ("pos_reference", "=", pos_reference), + ("access_token", "=", order_access_token), + *(state and [("state", "=", state)] or []), + ], + limit=1, + ) + ) + + def _get_sequence_number(self, table_id: int, session_id: int) -> int: + """ + :return: the new sequence number for the order. + """ + return ( + request.env["pos.order"] + .sudo() + .search( + [ + ( + "pos_reference", + "=like", + f"Order {session_id:0>5}-{900 + table_id}-____", + ), + ], + limit=1, + ) + .sequence_number + + 1 + ) or 1 diff --git a/addons/pos_self_order/controllers/qr_menu.py b/addons/pos_self_order/controllers/qr_menu.py new file mode 100644 index 00000000000..7601e573442 --- /dev/null +++ b/addons/pos_self_order/controllers/qr_menu.py @@ -0,0 +1,136 @@ +# -*- coding: utf-8 -*- + +from typing import Dict, Optional +import werkzeug + +from odoo import http +from odoo.http import request + +from odoo.addons.pos_self_order.controllers.utils import ( + get_pos_config_sudo, + get_any_pos_config_sudo, + get_table_sudo, +) +from odoo.addons.pos_self_order.models.pos_config import PosConfig +from odoo.addons.pos_self_order.models.pos_restaurant import RestaurantTable + + +class PosQRMenuController(http.Controller): + """ + This is the controller for the POS Self Order App + There is one main route that the client will use to access the POS Self Order App: /menu + This route will render the LANDING PAGE of the POS Self Order App + And it will pass the needed data to the template: the list of products, pos_config_id, table_id, company_name, currency... + After that the client will be able to navigate to the /products route w/o additional requests + to the server, using client side routing. + """ + + @http.route("/menu", auth="public") + def pos_self_order_redirect(self): + return request.redirect(f"/menu/{get_any_pos_config_sudo().id}") + + @http.route( + [ + "/menu/", + "/menu//products", + "/menu//products/", + "/menu//cart", + "/menu//orders", + ], + auth="public", + website=True, + sitemap=True, + ) + def pos_self_order_start( + self, pos_name: str, at: Optional[str] = None, product_id: Optional[int] = None + ): + """ + The user gets this route from the QR code that they scan at the table + :param pos_name: the name of the pos config: can be the id or the slugified name of the pos config. (e.g. "3" or "bar-3") + :param at: the access token of the table; we call this argument "at" because + it will be displayed in the url ( as a query param ), and "at" is more user friendly than "table_access_token" + the user is allowed to order only if this "at" matches the access token of a table + :param product_id: the id of the product that the user wants to see the details of; + we never actually use this argument in this function ( it will be read by the client side router ), + but we still have it here, because otherwise we get a Warning in the logs + :return: the rendered template + """ + return request.render( + "pos_self_order.index", + { + "session_info": { + **request.env["ir.http"].get_frontend_session_info(), + "currencies": request.env["ir.http"].get_currencies(), + "pos_self_order_data": self._get_self_order_config( + get_pos_config_sudo(pos_name), + get_table_sudo(table_access_token=at), + ), + } + }, + ) + + @http.route( + [ + "/menu/get-image/", + "/menu/get-image//", + ], + methods=["GET"], + type="http", + auth="public", + ) + def pos_self_order_get_image(self, product_id: int, image_size: Optional[int] = 128): + """ + This is the route that the POS Self Order App uses to GET THE PRODUCT IMAGES. + :return: the image of the product (or a default one in case no product is found) + or an exception if there is no pos configured as self order. + :rtype: binary + """ + if not get_any_pos_config_sudo(): + raise werkzeug.exceptions.Unauthorized() + + return ( + request.env["ir.binary"] + ._get_image_stream_from( + request.env["product.product"].sudo().browse(product_id), + field_name=f"image_{image_size}", + ) + .get_response() + ) + + @http.route( + "/menu/get-bg-image/", methods=["GET"], type="http", auth="public" + ) + def pos_self_order_get_bg_image(self, pos_config_id: int): + """ + Gets the background image for this self order + :return: the bg image + :rtype: binary + """ + pos_config_sudo = get_pos_config_sudo(pos_config_id) + + if not pos_config_sudo.self_order_image: + raise werkzeug.exceptions.NotFound() + + return ( + request.env["ir.binary"] + ._get_image_stream_from(pos_config_sudo, field_name="self_order_image") + .get_response() + ) + + def _get_self_order_config( + self, pos_config_sudo: PosConfig, table_sudo: RestaurantTable + ) -> Dict: + """ + Returns the necessary information for the POS Self Order App + """ + return { + **pos_config_sudo._get_self_order_data(), + **( + table_sudo + and pos_config_sudo.has_active_session + and pos_config_sudo.self_order_table_mode + # having the table_id in the frontend means that the client will be able to order + and {"table": table_sudo._get_self_order_data()} + or {} + ), + } diff --git a/addons/pos_self_order/controllers/utils.py b/addons/pos_self_order/controllers/utils.py new file mode 100644 index 00000000000..b2f8463a3d1 --- /dev/null +++ b/addons/pos_self_order/controllers/utils.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- + + +import werkzeug +from typing import Optional + +from odoo.http import request +from odoo.addons.http_routing.models.ir_http import unslug +from odoo.addons.pos_self_order.models.pos_config import PosConfig +from odoo.addons.pos_restaurant.models.pos_restaurant import RestaurantTable + + +def get_pos_config_sudo(pos_config_name: str) -> PosConfig: + """ + Returns the PosConfig if pos_config_id exist and the pos is configured to allow the menu to be viewed online. + If not, it raises a NotFound + :param pos_config_name: The name of the pos config. Can be the id or the slug. ex: 3 or Bar-3 + """ + return ( + request.env["pos.config"] + .sudo() + .search( + [ + ("id", "=", unslug(str(pos_config_name))[1]), + ("self_order_view_mode", "=", True), + ], + limit=1, + ) + ) or _raise(werkzeug.exceptions.NotFound()) + + +def get_any_pos_config_sudo() -> PosConfig: + """ + Returns a PosConfig that allows the QR code menu, if there is one, + or raises a NotFound otherwise + """ + return ( + request.env["pos.config"].sudo().search([("self_order_view_mode", "=", True)], limit=1) + ) or _raise(werkzeug.exceptions.NotFound()) + + +def get_table_sudo(table_access_token: Optional[str]) -> Optional[RestaurantTable]: + return table_access_token and ( + request.env["restaurant.table"] + .sudo() + .search([("access_token", "=", table_access_token), ("active", "=", True)], limit=1) + ) + + +def _raise(e): + raise e diff --git a/addons/pos_self_order/data/restaurant_table_data.xml b/addons/pos_self_order/data/restaurant_table_data.xml new file mode 100644 index 00000000000..d7e6fe7b802 --- /dev/null +++ b/addons/pos_self_order/data/restaurant_table_data.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/addons/pos_self_order/demo/pos_restaurant_demo.xml b/addons/pos_self_order/demo/pos_restaurant_demo.xml index 446d6fcb5ce..30de26cfd9e 100644 --- a/addons/pos_self_order/demo/pos_restaurant_demo.xml +++ b/addons/pos_self_order/demo/pos_restaurant_demo.xml @@ -1,6 +1,17 @@ - - True - + + + True + True + + + + diff --git a/addons/pos_self_order/models/__init__.py b/addons/pos_self_order/models/__init__.py index 6e71cd40aef..3b6f3f5d121 100644 --- a/addons/pos_self_order/models/__init__.py +++ b/addons/pos_self_order/models/__init__.py @@ -1,6 +1,9 @@ # -*- coding: utf-8 -*- -from . import res_config_settings -from . import pos_config -from . import pos_self_order_custom_link from . import ir_http +from . import pos_config +from . import pos_order +from . import pos_restaurant +from . import pos_self_order_custom_link +from . import product_product +from . import res_config_settings diff --git a/addons/pos_self_order/models/ir_http.py b/addons/pos_self_order/models/ir_http.py index 701f876f883..bc6d83e12f8 100644 --- a/addons/pos_self_order/models/ir_http.py +++ b/addons/pos_self_order/models/ir_http.py @@ -4,9 +4,9 @@ from odoo import models class IrHttp(models.AbstractModel): - _inherit = 'ir.http' + _inherit = "ir.http" @classmethod def _get_translation_frontend_modules_name(cls): mods = super()._get_translation_frontend_modules_name() - return mods + ['pos_self_order'] + return mods + ["pos_self_order"] diff --git a/addons/pos_self_order/models/pos_config.py b/addons/pos_self_order/models/pos_config.py index b5b5993958a..984c72d6ebd 100644 --- a/addons/pos_self_order/models/pos_config.py +++ b/addons/pos_self_order/models/pos_config.py @@ -1,26 +1,104 @@ # -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. -from odoo import fields, models +from typing import Optional, List, Dict, Callable +from werkzeug.urls import url_quote +import base64 + + +from odoo import api, fields, models, modules +from odoo.tools import file_open, split_every + +from odoo.addons.pos_self_order.models.product_product import ProductProduct +from odoo.addons.pos_self_order.models.pos_order import PosOrderLine class PosConfig(models.Model): _inherit = "pos.config" + def _self_order_default_image_name(self) -> str: + return "default_background.jpg" + + def _self_order_default_image(self) -> bytes: + image_path = modules.get_module_resource( + "pos_self_order", "static/img", self._self_order_default_image_name() + ) + return base64.b64encode(file_open(image_path, "rb").read()) + self_order_view_mode = fields.Boolean( string="QR Code Menu", help="Allow customers to view the menu on their phones by scanning the QR code on the table", ) + self_order_table_mode = fields.Boolean( + string="Self Order", + help="Allow customers to Order from their phones", + ) + self_order_pay_after = fields.Selection( + [("each", "Each Order"), ("meal", "Meal")], + string="Pay After:", + default="each", + help="Choose when the customer will pay", + required=True, + ) self_order_image = fields.Image( string="Self Order Image", help="Image to display on the self order screen", - max_width=1920, max_height=1080, + max_width=1920, + max_height=1080, + default=_self_order_default_image, ) self_order_image_name = fields.Char( string="Self Order Image Name", help="Name of the image to display on the self order screen", + default=_self_order_default_image_name, ) + @api.model_create_multi + def create(self, vals_list): + """ + We want self ordering to be enabled by default + (This would have been nicer to do using a default value + directly on the fields, but `module_pos_restaurant` would not be + known at the time that the function for this default value would run) + """ + for vals in vals_list: + if vals.get("module_pos_restaurant"): + vals.update( + { + "self_order_view_mode": True, + "self_order_table_mode": True, + } + ) + return super().create(vals_list) + + @api.depends("module_pos_restaurant") + def _compute_self_order(self): + """ + Self ordering will only be enabled for restaurants + """ + for record in self: + if not record.module_pos_restaurant: + record.self_order_view_mode = False + record.self_order_table_mode = False + + def _get_self_order_route(self, table_id: Optional[int] = None) -> str: + self.ensure_one() + base_route = f"/menu/{self.id}" + if not self.self_order_table_mode: + return base_route + table_access_token = ( + self.env["restaurant.table"] + .search( + [("active", "=", True), *(table_id and [("id", "=", table_id)] or [])], limit=1 + ) + .access_token + ) + return f"{base_route}?at={table_access_token}" + + def _get_self_order_url(self, table_id: Optional[int] = None) -> str: + self.ensure_one() + return url_quote(self.get_base_url() + self._get_self_order_route(table_id)) + def preview_self_order_app(self): """ This function is called when the user clicks on the "Preview App" button @@ -29,6 +107,126 @@ class PosConfig(models.Model): self.ensure_one() return { "type": "ir.actions.act_url", - "url": f"/menu/{self.id}", + "url": self._get_self_order_route(), "target": "new", } + + def _get_self_order_custom_links(self) -> List[Dict[str, str]]: + """ + On the landing page of the app we can have a number of custom links + that are defined by the restaurant employee in the backend. + This function returns a list of dictionaries with the attributes of each link + that is available for the POS with id pos_config_id. + """ + self.ensure_one() + return ( + self.env["pos_self_order.custom_link"] + .sudo() + .search_read( + [ + "|", + ("pos_config_ids", "in", [self.id]), + ("pos_config_ids", "=", False), + ], + fields=["name", "url", "style"], + order="sequence", + ) + ) + + def _get_available_products(self) -> ProductProduct: + """ + This function returns the products that are available in the given PosConfig + """ + self.ensure_one() + return ( + self.env["product.product"] + .sudo() + .search( + [ + ("available_in_pos", "=", True), + *( + self.limit_categories + and self.iface_available_categ_ids + and [("pos_categ_id", "in", self.iface_available_categ_ids.ids)] + or [] + ), + ], + order="pos_categ_id.sequence asc nulls last", + ) + ) + + def _get_self_order_data(self) -> Dict: + self.ensure_one() + return { + "pos_config_id": self.id, + "company_name": self.company_id.name, + "currency_id": self.currency_id.id, + "show_prices_with_tax_included": self.iface_tax_included == "total", + "custom_links": self._get_self_order_custom_links(), + "products": self._get_available_products()._get_self_order_data(self), + "has_active_session": self.has_active_session, + "orderline_unique_keys": PosOrderLine._get_unique_keys(), + } + + def _generate_data_for_qr_codes_page(self, cols: int = 4) -> Dict[str, List[Dict]]: + """ + :cols: the number of qr codes per row + """ + self.ensure_one() + return { + "floors": self._split_qr_codes_list( + self._get_qr_codes_info(cols * cols), + cols, + ) + } + + def _get_qr_codes_info(self, total_number: int) -> List[Dict]: + """ + total_number: the number of qr codes to generate (in the case where we don't have + floor management) + return: a list of dictionaries with the following keys: + - name: the name of the floor + - tables: a list of dictionaries with the following keys: + - id: the id of the table + - url: the url of the table + - name?: the name of the table + """ + self.ensure_one() + if self.self_order_table_mode: + return self.floor_ids._get_data_for_qr_codes_page(self._get_self_order_url) + else: + return self._get_default_qr_codes(total_number, self._get_self_order_url) + + def _split_qr_codes_list(self, floors: List[Dict], cols: int) -> List[Dict]: + """ + :floors: the list of floors + :cols: the number of qr codes per row + """ + self.ensure_one() + return [ + { + "name": floor.get("name"), + "rows_of_tables": list(split_every(cols, floor["tables"], list)), + } + for floor in floors + ] + + def _get_default_qr_codes( + self, number: int, url: Callable[[Optional[int]], str] + ) -> List[Dict]: + """ + :number: the number of qr codes to generate + :url: a function that takes a table id and returns the url of the table + """ + self.ensure_one() + return [ + { + "tables": [ + { + "id": 0, + "url": url(), + } + ] + * number, + } + ] diff --git a/addons/pos_self_order/models/pos_order.py b/addons/pos_self_order/models/pos_order.py new file mode 100644 index 00000000000..552ce181baf --- /dev/null +++ b/addons/pos_self_order/models/pos_order.py @@ -0,0 +1,83 @@ +# -*- coding: utf-8 -*- +# Part of Odoo. See LICENSE file for full copyright and licensing details. + +import re +from typing import Dict, Union + +from odoo import models + + +class PosOrderLine(models.Model): + _inherit = "pos.order.line" + + def _export_for_ui(self, orderline): + return { + "uuid": orderline.uuid, + "note": orderline.note, + **super()._export_for_ui(orderline), + } + + def _get_description(self): + """ + The pos sends a "description" key to the backend, which is a string containing the selected value for + each attribute of the product, separated by a comma. In the db we end up storing the + "full_product_name", which is composed of the product name and the description. + :line.full_product_name: ex: "Desk Organizer (M, Leather)" + :return: ex: "M, Leather" + """ + self.ensure_one() + description = re.findall(r"\(([^)]+)\)", self.full_product_name) + if description: + # It might happen that the product has a name with parenthesis. ex: "Salad (Vegie)" + # In that case the full_product_name will be "Salad (Vegie) (Small)", but are interested in returning the variant "Small" + # That's why we return the last element of the list + return description[-1] + return "" + + @staticmethod + def _get_unique_keys(): + """ + These are the keys that define the uniqueness of an orderline. + We use them to check if 2 orderlines can be merged or not. + """ + return ["product_id", "description", "customer_note"] + + +class PosOrder(models.Model): + _inherit = "pos.order" + + def _export_for_self_order(self) -> Dict: + """ + Given an order, it returns a dictionary with the keys that we need in the frontend + """ + self.ensure_one() + return { + "pos_reference": self.pos_reference, + "access_token": self.access_token, + "state": self.state, + "date": str(self.date_order), + "amount_total": self.amount_total, + "amount_tax": self.amount_tax, + "items": [ + { + "product_id": line.product_id.id, + "qty": line.qty, + "customer_note": line.customer_note, + "price_extra": line.product_id._get_price_info( + self.config_id, + line.price_extra, + ), + "description": line._get_description(), + } + for line in self.lines + ], + } + + def _get_self_order_data(self) -> Dict[str, Union[str, int]]: + return { + "id": self.pos_reference, + "sequence_number": self.sequence_number, + "access_token": self.access_token, + "session_id": self.session_id.id, + "table_id": self.table_id.id, + } diff --git a/addons/pos_self_order/models/pos_restaurant.py b/addons/pos_self_order/models/pos_restaurant.py new file mode 100644 index 00000000000..8f21f0fd1a1 --- /dev/null +++ b/addons/pos_self_order/models/pos_restaurant.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +# Part of Odoo. See LICENSE file for full copyright and licensing details. + +import uuid +from typing import Dict, Callable, List, Optional + +from odoo import api, fields, models + + +class RestaurantFloor(models.Model): + _inherit = "restaurant.floor" + + def _get_data_for_qr_codes_page(self, url: Callable): + return [ + { + "name": floor.name, + "tables": floor.table_ids.filtered("active")._get_data_for_qr_codes_page(url), + } + for floor in self + ] + + +class RestaurantTable(models.Model): + _inherit = "restaurant.table" + + access_token = fields.Char( + "Security Token", + copy=False, + required=True, + readonly=True, + default=lambda self: self._get_access_token(), + ) + + @staticmethod + def _get_access_token(): + return uuid.uuid4().hex[:8] + + def _get_self_order_data(self) -> Dict: + self.ensure_one() + return self.read(["name", "access_token"])[0] + + def _get_data_for_qr_codes_page(self, url: Callable[[Optional[int]], str]) -> List[Dict]: + return [ + { + "id": table.id, + "name": table.name, + "url": url(table.id), + } + for table in self + ] + + @api.model + def _update_access_token(self): + """ + We define a new access token field in this file. + There might already be databases that have restaurant.table records. + They will now also get an access token each; the problem is that + because of the way `default` values work, all those tables that + exist in the db will get the same access token. + This method will be ran at the moment the pos_self_order module + is installed and will thus make sure that every record has a + different access token. + """ + tables = self.env["restaurant.table"].search([]) + for table in tables: + table.access_token = self._get_access_token() diff --git a/addons/pos_self_order/models/pos_self_order_custom_link.py b/addons/pos_self_order/models/pos_self_order_custom_link.py index 96398c981cf..315b120aa76 100644 --- a/addons/pos_self_order/models/pos_self_order_custom_link.py +++ b/addons/pos_self_order/models/pos_self_order_custom_link.py @@ -1,17 +1,21 @@ # -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. + from odoo import fields, models, api +from markupsafe import escape class PosSelfOrderCustomLink(models.Model): _name = "pos_self_order.custom_link" - _description = "Custom links that the restaurant can configure to be displayed on the self order screen" + _description = ( + "Custom links that the restaurant can configure to be displayed on the self order screen" + ) name = fields.Char(string="Label", required=True, translate=True) url = fields.Char(string="URL", required=True) pos_config_ids = fields.Many2many( "pos.config", - string="Point of Sales", + string="Points of Sale", domain="[('self_order_view_mode', '=', True)]", help="Select for which points of sale you want to display this link. Leave empty to display it for all points of sale. You have to select among the points of sale that have the 'QR Code Menu' feature enabled.", ) @@ -33,8 +37,8 @@ class PosSelfOrderCustomLink(models.Model): link_html = fields.Html("Preview", compute="_compute_link_html", store=True, readonly=True) sequence = fields.Integer("Sequence", default=1) - @api.depends('name', 'style') + @api.depends("name", "style") def _compute_link_html(self): for link in self: if link.name: - link.link_html = f"{link.name}" + link.link_html = f'{escape(link.name)}' diff --git a/addons/pos_self_order/models/product_product.py b/addons/pos_self_order/models/product_product.py new file mode 100644 index 00000000000..e1cf42aaefb --- /dev/null +++ b/addons/pos_self_order/models/product_product.py @@ -0,0 +1,107 @@ +# -*- coding: utf-8 -*- +# Part of Odoo. See LICENSE file for full copyright and licensing details. +from typing import List, Dict, Optional + +from odoo import models + +from odoo.addons.point_of_sale.models.pos_config import PosConfig + + +class ProductProduct(models.Model): + _inherit = "product.product" + + def _get_name(self) -> str: + """ + Returns the name of the product without the code. + ex: product_sudo.display_name is '[FURN_7888] Desk Stand with Screen (Red)' + :return: 'Desk Stand with Screen (Red)' (we remove the [FURN_7888] part) + """ + self.ensure_one() + return self.with_context(display_default_code=False).display_name + + def _filter_applicable_attributes(self, attributes_by_ptal_id: Dict) -> List[Dict]: + """ + The attributes_by_ptal_id is a dictionary that contains all the attributes that have + [('create_variant', '=', 'no_variant')] + This method filters out the attributes that are not applicable to the product in self + """ + self.ensure_one() + return [ + attributes_by_ptal_id[id] + for id in self.attribute_line_ids.ids + if attributes_by_ptal_id.get(id) is not None + ] + + def _get_attributes(self, pos_config_sudo: PosConfig) -> List[Dict]: + self.ensure_one() + + attributes = self._filter_applicable_attributes( + self.env["pos.session"].sudo()._get_attributes_by_ptal_id() + ) + return self._add_price_info_to_attributes( + attributes, + pos_config_sudo, + ) + + def _add_price_info_to_attributes( + self, attributes: List[Dict], pos_config_sudo: PosConfig + ) -> List[Dict]: + """ + Here we replace the price_extra of each attribute value with a price_extra + dictionary that includes the price with taxes included and the price with taxes excluded + """ + self.ensure_one() + for attribute in attributes: + for value in attribute["values"]: + value.update( + { + "price_extra": self._get_price_info( + pos_config_sudo, value.get("price_extra") + ) + } + ) + return attributes + + def _get_price_info( + self, pos_config: PosConfig, price: Optional[float] = None, qty: int = 1 + ) -> Dict[str, float]: + """ + Function that returns a dict with the price info of a given product + """ + self.ensure_one() + # if price == None it means that a price was not passed as a parameter, so we use the product's list price + # it could happen that a price was passed, but it was 0; in that case we want to use this 0 as the argument, + # and not the product's list price + if price is None: + price = pos_config.pricelist_id._get_product_price( + self, qty, currency=pos_config.currency_id + ) + price_info = pos_config.default_fiscal_position_id.map_tax(self.taxes_id).compute_all( + price, pos_config.currency_id, qty, product=self + ) + + return { + "list_price": price_info["total_included"] + if pos_config.iface_tax_included == "total" + else price_info["total_excluded"], + "price_without_tax": price_info["total_excluded"], + "price_with_tax": price_info["total_included"], + } + + def _get_self_order_data(self, pos_config: PosConfig) -> List[Dict]: + """ + returns the list of products with the necessary info for the self order app + """ + return [ + { + "price_info": product._get_price_info(pos_config), + "has_image": bool(product.image_1920), + "attributes": product._get_attributes(pos_config), + "name": product._get_name(), + "product_id": product.id, + "description_sale": product.description_sale, + "tag": product.pos_categ_id.name if product.pos_categ_id else "Other", + "is_pos_groupable": product.uom_id.is_pos_groupable, + } + for product in self + ] diff --git a/addons/pos_self_order/models/res_config_settings.py b/addons/pos_self_order/models/res_config_settings.py index 1ddfe90bf66..713bde19d8b 100644 --- a/addons/pos_self_order/models/res_config_settings.py +++ b/addons/pos_self_order/models/res_config_settings.py @@ -1,19 +1,35 @@ # -*- coding: utf-8 -*- from odoo import models, fields, api -from odoo.tools import split_every - class ResConfigSettings(models.TransientModel): _inherit = "res.config.settings" pos_self_order_view_mode = fields.Boolean( - compute="_compute_pos_module_pos_self_order", store=True, readonly=False) + compute="_compute_pos_module_pos_self_order", store=True, readonly=False + ) + pos_self_order_table_mode = fields.Boolean( + compute="_compute_pos_module_pos_self_order", store=True, readonly=False + ) + pos_self_order_pay_after = fields.Selection( + [("each", "Each Order"), ("meal", "Meal")], + string="Pay After:", + default="each", + help="Choose when the customer will pay", + readonly=False, + required=True, + ) pos_self_order_image = fields.Image( - compute="_compute_pos_module_pos_self_order", store=True, readonly=False, max_width=1920, max_height=1080) + compute="_compute_pos_module_pos_self_order", + store=True, + readonly=False, + max_width=1920, + max_height=1080, + ) pos_self_order_image_name = fields.Char( - compute="_compute_pos_module_pos_self_order", store=True, readonly=False) + compute="_compute_pos_module_pos_self_order", store=True, readonly=False + ) @api.depends("pos_config_id") def _compute_pos_module_pos_self_order(self): @@ -22,6 +38,8 @@ class ResConfigSettings(models.TransientModel): res_config.update( { "pos_self_order_view_mode": False, + "pos_self_order_table_mode": False, + "pos_self_order_pay_after": "each", "pos_self_order_image": False, "pos_self_order_image_name": False, } @@ -30,31 +48,32 @@ class ResConfigSettings(models.TransientModel): res_config.update( { "pos_self_order_view_mode": res_config.pos_config_id.self_order_view_mode, + "pos_self_order_table_mode": res_config.pos_config_id.self_order_table_mode, + "pos_self_order_pay_after": res_config.pos_config_id.self_order_pay_after, "pos_self_order_image": res_config.pos_config_id.self_order_image, "pos_self_order_image_name": res_config.pos_config_id.self_order_image_name, } ) + # self_order_table_mode is only available if self_order_view_mode is True + @api.onchange("pos_self_order_view_mode") + def _onchange_pos_self_order_view_mode(self): + if not self.pos_self_order_view_mode: + self.pos_self_order_table_mode = False + + @api.onchange("pos_self_order_table_mode") + def _onchange_pos_self_order_table_mode(self): + if self.pos_self_order_table_mode: + self.pos_self_order_view_mode = True + def generate_qr_codes_page(self): """ Generate the data needed to print the QR codes page """ - no_of_qr_codes_per_page = 16 - qr_codes_to_print = [ - { - "id": 0, - "url": f"{self.get_base_url()}/menu/{self.pos_config_id.id}", - } - for i in range(no_of_qr_codes_per_page) - ] - data = { - "groups_of_tables": list(split_every(4, qr_codes_to_print, list)), - } - return self.env.ref("pos_self_order.report_self_order_qr_codes_page").report_action([], data=data) + return self.env.ref("pos_self_order.report_self_order_qr_codes_page").report_action( + [], data=self.pos_config_id._generate_data_for_qr_codes_page(cols=3) + ) def preview_self_order_app(self): - """ - This function calls the preview_self_order_app function of the pos.config model - """ self.ensure_one() return self.pos_config_id.preview_self_order_app() diff --git a/addons/pos_self_order/static/img/default_background.jpg b/addons/pos_self_order/static/img/default_background.jpg new file mode 100644 index 00000000000..9c7d8b77791 Binary files /dev/null and b/addons/pos_self_order/static/img/default_background.jpg differ diff --git a/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.js b/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.js new file mode 100644 index 00000000000..a1a7af3d3ec --- /dev/null +++ b/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.js @@ -0,0 +1,8 @@ +/** @odoo-module */ + +import { Component } from "@odoo/owl"; + +export class IncrementCounter extends Component { + static template = "pos_self_order.IncrementCounter"; + static props = ["value", "onClick"]; +} diff --git a/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.scss b/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.scss new file mode 100644 index 00000000000..1593cdecea1 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.scss @@ -0,0 +1,4 @@ +.o_self_order_incr_button button { + width: 40px; + height: 40px; +} \ No newline at end of file diff --git a/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.xml b/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.xml new file mode 100644 index 00000000000..61f24267e8c --- /dev/null +++ b/addons/pos_self_order/static/src/Components/IncrementCounter/IncrementCounter.xml @@ -0,0 +1,14 @@ + + + +
+ +
+ +
+ + diff --git a/addons/pos_self_order/static/src/Components/Loading/Loading.js b/addons/pos_self_order/static/src/Components/Loading/Loading.js new file mode 100644 index 00000000000..cd9a9ef9422 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/Loading/Loading.js @@ -0,0 +1,8 @@ +/** @odoo-module */ + +import { Component } from "@odoo/owl"; + +export class Loading extends Component { + static template = "pos_self_order.Loading"; + static props = []; +} diff --git a/addons/pos_self_order/static/src/Components/Loading/Loading.xml b/addons/pos_self_order/static/src/Components/Loading/Loading.xml new file mode 100644 index 00000000000..ee214fef972 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/Loading/Loading.xml @@ -0,0 +1,10 @@ + + + +
+ +
+ + diff --git a/addons/pos_self_order/static/src/Components/MainButton/MainButton.js b/addons/pos_self_order/static/src/Components/MainButton/MainButton.js new file mode 100644 index 00000000000..cfd5f986076 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/MainButton/MainButton.js @@ -0,0 +1,8 @@ +/** @odoo-module */ + +import { Component } from "@odoo/owl"; + +export class MainButton extends Component { + static template = "pos_self_order.MainButton"; + static props = { slots: Object, onClick: Function }; +} diff --git a/addons/pos_self_order/static/src/Components/MainButton/MainButton.xml b/addons/pos_self_order/static/src/Components/MainButton/MainButton.xml new file mode 100644 index 00000000000..0cafd90996a --- /dev/null +++ b/addons/pos_self_order/static/src/Components/MainButton/MainButton.xml @@ -0,0 +1,11 @@ + + + +
+ + +
+ + diff --git a/addons/pos_self_order/static/src/NavBar/NavBar.js b/addons/pos_self_order/static/src/Components/NavBar/NavBar.js similarity index 57% rename from addons/pos_self_order/static/src/NavBar/NavBar.js rename to addons/pos_self_order/static/src/Components/NavBar/NavBar.js index ee5b3ed4427..feadc43a0ab 100644 --- a/addons/pos_self_order/static/src/NavBar/NavBar.js +++ b/addons/pos_self_order/static/src/Components/NavBar/NavBar.js @@ -4,7 +4,12 @@ import { Component } from "@odoo/owl"; import { useSelfOrder } from "@pos_self_order/SelfOrderService"; export class NavBar extends Component { static template = "pos_self_order.NavBar"; - static props = { previousPage: String }; + static props = { + customText: { type: String, optional: true }, + goBack: { type: String }, + class: { type: String, optional: true }, + }; + static defaultProps = { class: "" }; setup() { this.selfOrder = useSelfOrder(); } diff --git a/addons/pos_self_order/static/src/Components/NavBar/NavBar.scss b/addons/pos_self_order/static/src/Components/NavBar/NavBar.scss new file mode 100644 index 00000000000..8b8686fa993 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/NavBar/NavBar.scss @@ -0,0 +1,10 @@ +.o_self_order_navbar { + // we have to set a max-height to make the transition work + max-height: 300px; + transition: all 0.25s linear; +} + +.o_self_order_navbar_hide { + max-height: 0; + overflow: hidden; +} \ No newline at end of file diff --git a/addons/pos_self_order/static/src/Components/NavBar/NavBar.xml b/addons/pos_self_order/static/src/Components/NavBar/NavBar.xml new file mode 100644 index 00000000000..d039ca4de16 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/NavBar/NavBar.xml @@ -0,0 +1,18 @@ + + + + + + diff --git a/addons/pos_self_order/static/src/Components/Order/Order.js b/addons/pos_self_order/static/src/Components/Order/Order.js new file mode 100644 index 00000000000..ae724cac57b --- /dev/null +++ b/addons/pos_self_order/static/src/Components/Order/Order.js @@ -0,0 +1,15 @@ +/** @odoo-module */ + +import { useSelfOrder } from "@pos_self_order/SelfOrderService"; +import { Component } from "@odoo/owl"; +import { ProductCard } from "@pos_self_order/Components/ProductCard/ProductCard"; +import { OrderLines } from "@pos_self_order/Components/OrderLines/OrderLines"; +import { PriceDetails } from "@pos_self_order/Components/PriceDetails/PriceDetails"; +export class Order extends Component { + static template = "pos_self_order.Order"; + static components = { ProductCard, OrderLines, PriceDetails }; + static props = ["order"]; + setup() { + this.selfOrder = useSelfOrder(); + } +} diff --git a/addons/pos_self_order/static/src/Components/Order/Order.xml b/addons/pos_self_order/static/src/Components/Order/Order.xml new file mode 100644 index 00000000000..8f29cf23f72 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/Order/Order.xml @@ -0,0 +1,23 @@ + + + +
+
+
+
+ +
+

+

+
+ +
+ +
+
+
+ + diff --git a/addons/pos_self_order/static/src/Components/OrderLines/OrderLines.js b/addons/pos_self_order/static/src/Components/OrderLines/OrderLines.js new file mode 100644 index 00000000000..fec8bb38c3c --- /dev/null +++ b/addons/pos_self_order/static/src/Components/OrderLines/OrderLines.js @@ -0,0 +1,19 @@ +/** @odoo-module */ + +import { Component } from "@odoo/owl"; +import { useSelfOrder } from "@pos_self_order/SelfOrderService"; +import { ProductCard } from "../ProductCard/ProductCard"; + +export class OrderLines extends Component { + static template = "pos_self_order.OrderLines"; + static components = { ProductCard }; + static props = ["lines"]; + setup() { + this.selfOrder = useSelfOrder(); + } + formatProduct(product) { + return (({ description_sale, has_image, ...rest }) => ({ has_image: false, ...rest }))( + product + ); + } +} diff --git a/addons/pos_self_order/static/src/Components/OrderLines/OrderLines.xml b/addons/pos_self_order/static/src/Components/OrderLines/OrderLines.xml new file mode 100644 index 00000000000..b8972280e11 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/OrderLines/OrderLines.xml @@ -0,0 +1,11 @@ + + + + + + + + + \ No newline at end of file diff --git a/addons/pos_self_order/static/src/Components/PriceDetails/PriceDetails.js b/addons/pos_self_order/static/src/Components/PriceDetails/PriceDetails.js new file mode 100644 index 00000000000..96cea7db236 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/PriceDetails/PriceDetails.js @@ -0,0 +1,12 @@ +/** @odoo-module */ + +import { Component } from "@odoo/owl"; +import { useSelfOrder } from "@pos_self_order/SelfOrderService"; + +export class PriceDetails extends Component { + static template = "pos_self_order.PriceDetails"; + static props = { tax: Number, total: Number }; + setup() { + this.selfOrder = useSelfOrder(); + } +} diff --git a/addons/pos_self_order/static/src/Components/PriceDetails/PriceDetails.xml b/addons/pos_self_order/static/src/Components/PriceDetails/PriceDetails.xml new file mode 100644 index 00000000000..0e87861a42c --- /dev/null +++ b/addons/pos_self_order/static/src/Components/PriceDetails/PriceDetails.xml @@ -0,0 +1,15 @@ + + + +
+
+ Tax: + +
+
+ Total: + +
+
+ + diff --git a/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.js b/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.js new file mode 100644 index 00000000000..d5cefd93af5 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.js @@ -0,0 +1,55 @@ +/** @odoo-module */ + +import { Component } from "@odoo/owl"; +import { useSelfOrder } from "@pos_self_order/SelfOrderService"; +import { useForwardRefToParent } from "@web/core/utils/hooks"; + +export class ProductCard extends Component { + static template = "pos_self_order.ProductCard"; + static props = ["product", "orderLine?", "currentProductCard?", "class?"]; + static defaultProps = { class: "" }; + setup() { + this.selfOrder = useSelfOrder(); + useForwardRefToParent("currentProductCard"); + this.qtyInCart = !this.props.orderLine && this.getQtyInCart(); + } + clickOnProduct() { + const product = this.props.product; + if (!this.canOpenProductMainView(product)) { + return; + } + if (this.env.getCurrentRoute()[0] === "cart") { + this.selfOrder.setCurrentlyEditedOrderLine(this.props?.orderLine); + } + this.env.navigate("/products/" + product.product_id); + } + + canOpenProductMainView(product) { + return ( + this.selfOrder.table || + product.has_image || + product.description_sale || + product.attributes.length + ); + } + getQtyInCart() { + const cart = this.selfOrder.cart; + const product = this.props.product; + return cart + .filter((x) => x.product_id === product.product_id) + .reduce((sum, x) => sum + x.qty, 0); + } + getQtyInCartString() { + return `${this.props.orderLine.qty} x ${this.selfOrder.formatMonetary( + this.props.product.price_info.list_price + + (this.props.orderLine?.price_extra.list_price || 0) + )}`; + } + getTotalPriceString() { + return `${this.selfOrder.formatMonetary( + (this.props.orderLine?.qty || 1) * + (this.props.product.price_info.list_price + + (this.props.orderLine?.price_extra.list_price || 0)) + )}`; + } +} diff --git a/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.scss b/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.scss new file mode 100644 index 00000000000..9da785a9824 --- /dev/null +++ b/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.scss @@ -0,0 +1,41 @@ +.break-line { + box-sizing: border-box; + overflow: hidden; + display: -webkit-box; + -webkit-box-orient: vertical; + -webkit-line-clamp: 2; +} + +.o_self_order_item_card_image { + width: 110px !important; + min-width: 110px; + min-height: 110px; + + & img { + object-fit: cover; + } +} +.o_self_order_item_card { + border-right: 1px solid $border-color; + border-bottom: 1px solid $border-color; + + @include media-breakpoint-down(md) { + &:nth-child(1n) { + border-right: 0; + } + } + @include media-breakpoint-up(md) { + &:nth-child(2n + 1) { + border-right: 0; + } + } + @include media-breakpoint-up(xl) { + &:nth-child(2n + 1) { + border-right: 1px solid $border-color; + } + + &:nth-child(4n + 1) { + border-right: 0; + } + } +} \ No newline at end of file diff --git a/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.xml b/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.xml new file mode 100644 index 00000000000..b5a67016d5f --- /dev/null +++ b/addons/pos_self_order/static/src/Components/ProductCard/ProductCard.xml @@ -0,0 +1,59 @@ + + + +
+
+
+ +

+ + + +
+