[FIX] point_of_sale: prevent duplicate preparation ticket

Before this change, when a device sent an order in preparation via the
ticket printer, this could result in the same order being printed by
multiple devices, as the order was not synchronized after it was sent.

The error is a bit tricky, because if the user had installed a
preparation screen, the order was sent to the preparation screen via
syncAllOrders. In this case, the order was correctly synchronized and
the other devices were informed of the changes.

This commit adds two things.
- We check the server before sending the order to preparation to make
sure it has not already been sent.
- Even when the user does not have a preparation display, the order
will be synchronized after being sent to a printer.

closes odoo#220716

X-original-commit: 9240148
Related: odoo/enterprise#91093
Signed-off-by: Adrien Guilliams (adgu) <adgu@odoo.com>
Signed-off-by: David Monnom (moda) <moda@odoo.com>

Author: davidmonnom

addons/point_of_sale/models/pos_order.py

@@ -355,6 +355,34 @@ def _get_pos_anglo_saxon_price_unit(self, product, partner_id, quantity):
         ('to_invoice', 'To Invoice'),
     ], string='Invoice Status', compute='_compute_invoice_status')
 
+    def get_preparation_change(self):
+        self.ensure_one()
+        return {
+            'last_order_preparation_change': self.last_order_preparation_change,
+        }
+
+    def _ensure_to_keep_last_preparation_change(self, vals):
+        for record in self:
+            if record.last_order_preparation_change:
+                change = json.loads(record.last_order_preparation_change)
+                if not change.get('metadata'):
+                    return
+
+                local_change = json.loads(vals.get('last_order_preparation_change', '{}'))
+                if not local_change.get('metadata'):
+                    vals['last_order_preparation_change'] = record.last_order_preparation_change
+                    return
+
+                server_date = fields.Datetime.from_string(change['metadata'].get('serverDate'))
+                local_date = fields.Datetime.from_string(local_change['metadata'].get('serverDate'))
+
+                if server_date > local_date:
+                    _logger.warning("Preparation changes were outdated, probably linked to a synching issue.")
+                    vals['last_order_preparation_change'] = record.last_order_preparation_change
+                else:
+                    local_change['metadata']['serverDate'] = fields.Datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                    vals['last_order_preparation_change'] = json.dumps(local_change)
+
     @api.depends('account_move')
     def _compute_invoice_status(self):
         for order in self:
@@ -1120,6 +1148,7 @@ def sync_from_ui(self, orders):
 
             existing_order = self._get_open_order(order)
             if existing_order and existing_order.state == 'draft':
+                existing_order._ensure_to_keep_last_preparation_change(order)
                 order_ids.append(self._process_order(order, existing_order))
                 _logger.info("PoS synchronisation #%d order %s updated pos.order #%d", sync_token, order_log_name, order_ids[-1])
             elif not existing_order:
@@ -1128,6 +1157,7 @@ def sync_from_ui(self, orders):
             else:
                 # In theory, this situation is unintended
                 # In practice it can happen when "Tip later" option is used
+                existing_order._ensure_to_keep_last_preparation_change(order)
                 order_ids.append(existing_order.id)
                 _logger.info("PoS synchronisation #%d order %s sync ignored for existing PoS order %s (state: %s)", sync_token, order_log_name, existing_order, existing_order.state)
 

addons/point_of_sale/static/src/app/models/pos_order.js

@@ -34,6 +34,7 @@ export class PosOrder extends Base {
         if (!vals.last_order_preparation_change) {
             this.last_order_preparation_change = {
                 lines: {},
+                metadata: {},
                 general_customer_note: "",
                 internal_note: "",
                 sittingMode: 0,
@@ -340,6 +341,9 @@ export class PosOrder extends Base {
         this.last_order_preparation_change.general_customer_note = this.general_customer_note;
         this.last_order_preparation_change.internal_note = this.internal_note;
         this.last_order_preparation_change.sittingMode = this.preset_id?.id || 0;
+        this.last_order_preparation_change.metadata = {
+            serverDate: serializeDateTime(DateTime.now()),
+        };
     }
 
     isEmpty() {

addons/point_of_sale/static/src/app/screens/receipt_screen/receipt_screen.js

@@ -35,7 +35,7 @@ export class ReceiptScreen extends Component {
             this.currentOrder.uiState.locked = true;
 
             if (!this.pos.config.module_pos_restaurant) {
-                this.pos.sendOrderInPreparation(order, { orderDone: true });
+                this.pos.checkPreparationStateAndSentOrderInPreparation(order, { orderDone: true });
             }
         });
     }

addons/point_of_sale/static/src/app/services/pos_store.js

@@ -507,7 +507,7 @@ export class PosStore extends WithLazyGetterTrap {
                     const orderPresetDate = DateTime.fromISO(order.preset_time);
                     const isSame = DateTime.now().hasSame(orderPresetDate, "day");
                     if (!order.preset_time || isSame) {
-                        await this.sendOrderInPreparation(order, {
+                        await this.checkPreparationStateAndSentOrderInPreparation(order, {
                             cancelled: true,
                             orderDone: true,
                         });
@@ -1660,8 +1660,41 @@ export class PosStore extends WithLazyGetterTrap {
     changesToOrder(order, skipped = false, orderPreparationCategories, cancelled = false) {
         return changesToOrder(order, skipped, orderPreparationCategories, cancelled);
     }
+    async checkPreparationStateAndSentOrderInPreparation(order, cancelled = false) {
+        if (typeof order.id !== "number") {
+            return this.sendOrderInPreparation(order, cancelled);
+        }
+
+        const data = await this.data.call("pos.order", "get_preparation_change", [order.id]);
+        const rawchange = data.last_order_preparation_change || "{}";
+        const lastChanges = JSON.parse(rawchange);
+        const lastServerDate = DateTime.fromSQL(lastChanges.metadata?.serverDate).toUTC();
+        const lastLocalDate = DateTime.fromSQL(
+            order.last_order_preparation_change?.metadata?.serverDate
+        ).toUTC();
+
+        if (lastServerDate.isValid && lastServerDate.ts != lastLocalDate.ts) {
+            this.dialog.add(AlertDialog, {
+                title: _t("Order Outdated"),
+                body: _t(
+                    "The order has been modified on another device. If you have modified existing " +
+                        "order lines, check that your changes have not been overwritten.\n\n" +
+                        "The order will be sent to the server with the last changes made on this device."
+                ),
+            });
+
+            // Update before syncing otherwise it will overwrite the last change
+            order.last_order_preparation_change = lastChanges;
+            await this.syncAllOrders({ orders: [order] });
+            return;
+        }
+
+        return this.sendOrderInPreparation(order, cancelled);
+    }
     // Now the printer should work in PoS without restaurant
     async sendOrderInPreparation(order, opts = {}) {
+        let isPrinted = false;
+
         if (this.config.printerCategories.size && !opts.byPassPrint) {
             try {
                 let reprint = false;
@@ -1688,19 +1721,25 @@ export class PosStore extends WithLazyGetterTrap {
                 if (reprint && opts.orderDone) {
                     return;
                 }
-                await this.printChanges(order, orderChange, reprint);
+                isPrinted = await this.printChanges(order, orderChange, reprint);
             } catch (e) {
                 console.info("Failed in printing the changes in the order", e);
             }
         }
         order.updateLastOrderChange();
+        // Ensure that other devices are aware of the changes
+        // Otherwise several devices can print the same changes
+        // We need to check if a preparation display is configured to avoid unnecessary sync
+        if (isPrinted && !this.config["<-pos_preparation_display.display.pos_config_ids"]?.length) {
+            await this.syncAllOrders({ orders: [order] });
+        }
     }
     async sendOrderInPreparationUpdateLastChange(o, cancelled = false) {
         if (this.data.network.offline) {
             this.data.network.warningTriggered = false;
             throw new ConnectionLostError();
         }
-        await this.sendOrderInPreparation(o, { cancelled });
+        await this.checkPreparationStateAndSentOrderInPreparation(o, { cancelled });
     }
 
     getStrNotes(note) {
@@ -1794,6 +1833,7 @@ export class PosStore extends WithLazyGetterTrap {
     }
 
     async printChanges(order, orderChange, reprint = false) {
+        let isPrinted = false;
         const unsuccedPrints = [];
 
         for (const printer of this.unwatched.printers) {
@@ -1812,6 +1852,8 @@ export class PosStore extends WithLazyGetterTrap {
                 const result = await this.printOrderChanges(data, printer);
                 if (!result.successful) {
                     unsuccedPrints.push(printer.config.name);
+                } else {
+                    isPrinted = true;
                 }
             }
         }
@@ -1824,6 +1866,8 @@ export class PosStore extends WithLazyGetterTrap {
                 body: _t("Failed in printing %s changes of the order", failedReceipts),
             });
         }
+
+        return isPrinted;
     }
 
     async prepareReceiptGroupedData(data) {

addons/point_of_sale/static/tests/unit/data/pos_order.data.js

@@ -3,6 +3,14 @@ import { models } from "@web/../tests/web_test_helpers";
 export class PosOrder extends models.ServerModel {
     _name = "pos.order";
 
+    get_preparation_change(id) {
+        const read = this.read([id]);
+        const changes = read[0]?.last_order_preparation_change || "{}";
+        return {
+            last_order_preparation_change: changes,
+        };
+    }
+
     _load_pos_data_fields() {
         return [];
     }

addons/pos_restaurant/static/src/app/services/pos_store.js

@@ -882,7 +882,10 @@ patch(PosStore.prototype, {
         const order = course.order_id;
         course.fired = true;
         order.deselectCourse();
-        await this.sendOrderInPreparation(order, { firedCourseId: course.id, byPassPrint: true });
+        await this.checkPreparationStateAndSentOrderInPreparation(order, {
+            firedCourseId: course.id,
+            byPassPrint: true,
+        });
         await this.printCourseTicket(course);
         return true;
     },