[IMP] point_of_sale: real time syncing

We use the built-in listener of the related records to keep track of all
of the changes. We then queue these changes and send them to the backend
automatically. This means that the pos ui developer never needs to think
about syncing their data to the server. It is done automatically.

`sync_from_ui` is now removed.

It performed a couple of actions:
1. Prepared the vals -> this is now done in `create` or `write` where
   needed
2. Performed side effects -> side effects are now moved in
   `action_pos_order_paid`, which is called by the client after
   validation.
3. It was used as a notifier -> modules that need to be notified of
   order creation and update can hook into `create` and `write`

Author: vlst-odoo

addons/point_of_sale/models/pos_config.py

@@ -10,7 +10,6 @@
 from odoo.http import request
 from odoo.exceptions import AccessError, ValidationError, UserError
 from odoo.tools import SQL, convert
-from odoo.osv import expression
 
 DEFAULT_LIMIT_LOAD_PRODUCT = 5000
 DEFAULT_LIMIT_LOAD_PARTNER = 100
@@ -202,49 +201,11 @@ def _get_default_tip_product(self):
     last_data_change = fields.Datetime(string='Last Write Date', readonly=True, compute='_compute_local_data_integrity', store=True)
     fallback_nomenclature_id = fields.Many2one('barcode.nomenclature', string="Fallback Nomenclature")
 
-    def notify_synchronisation(self, session_id, login_number, records={}):
-        self.ensure_one()
-        static_records = {}
-
-        for model, ids in records.items():
-            static_records[model] = self.env[model]._read_pos_record(ids, self.id)
-
-        self._notify('SYNCHRONISATION', {
-            'static_records': static_records,
-            'session_id': session_id,
-            'login_number': login_number,
-            'records': records
-        })
-
-    def read_config_open_orders(self, domain, record_ids=[]):
-        delete_record_ids = {}
-        dynamic_records = {}
-
-        for model, domain in domain.items():
-            ids = record_ids[model]
-            delete_record_ids[model] = [id for id in ids if not self.env[model].browse(id).exists()]
-            dynamic_records[model] = self.env[model].search(domain)
-
-        pos_order_data = dynamic_records.get('pos.order') or self.env['pos.order']
-        data = pos_order_data.read_pos_data([], self.id)
-
-        for key, records in dynamic_records.items():
-            fields = self.env[key]._load_pos_data_fields(self.id)
-            ids = list(set(records.ids + [record['id'] for record in data.get(key, [])]))
-            dynamic_records[key] = self.env[key].browse(ids).read(fields, load=False)
-
-        for key, value in data.items():
-            if key not in dynamic_records:
-                dynamic_records[key] = value
-
-        return {
-            'dynamic_records': dynamic_records,
-            'deleted_record_ids': delete_record_ids,
-        }
-
     @api.model
     def _load_pos_data_domain(self, data):
-        return [('id', '=', data['pos.session'][0]['config_id'])]
+        main_config = self.env['pos.config'].browse(data['pos.session'][0]['config_id'])
+        other_configs = main_config._configs_that_share_data()
+        return [('id', 'in', [main_config.id] + other_configs.ids)]
 
     def _load_pos_data(self, data):
         domain = self._load_pos_data_domain(data)
@@ -258,6 +219,58 @@ def _post_read_pos_data(self, data):
             data[0]['_IS_VAT'] = self.env.company.country_id.id in self.env.ref("base.europe").country_ids.ids
         return super()._post_read_pos_data(data)
 
+    def _configs_that_share_data(self):
+        self.ensure_one()
+        return self.trusted_config_ids
+
+    def notify_data_change(self, queue, login_number, id_updates):
+        if not self:
+            # No config is available to notify in certain scenarios (e.g., pre-display)
+            return
+        for config in self._configs_that_share_data() + self:
+            config._notify('DATA_CHANGED', {'queue': queue, 'login_number': login_number, 'config_id': self.id, 'id_updates': id_updates})
+
+    def flush(self, queue, login_number):
+
+        def get_record(model, id):
+            return self.env[model].search([('uuid', '=', id)], limit=1) if isinstance(id, str) else self.env[model].browse(id)
+
+        def replace_uuid_with_id(model, vals):
+            def adapt_value(model, key, value):
+                match self.env[model]._fields[key].type:
+                    case "many2one":
+                        return get_record(self.env[model]._fields[key].comodel_name, value).id
+                    case "many2many" | "one2many":
+                        return [(6, 0, [get_record(self.env[model]._fields[key].comodel_name, val).id for val in value])]
+                    case _:
+                        return value
+            return {key: adapt_value(model, key, value) for key, value in vals.items()}
+
+        id_updates = {}
+
+        for [operation, *data] in queue:
+            match operation:
+                case "CREATE":
+                    model, vals = data
+                    vals = {key: val for key, val in vals.items() if key[0] != '_'}
+                    new_record = self.env[model].create([replace_uuid_with_id(model, vals)])
+                    id_updates[vals['uuid']] = new_record.id
+                case "UPDATE":
+                    model, id, vals = data
+                    vals = {key: val for key, val in vals.items() if key[0] != '_'}
+                    record = get_record(model, id)
+                    record.write(replace_uuid_with_id(model, vals))
+                case "DELETE":
+                    model, id = data
+                    record = get_record(model, id)
+                    if record.exists():
+                        record.unlink()
+                case _:
+                    pass
+
+        self.notify_data_change(queue, login_number, id_updates)
+        return id_updates
+
     @api.depends('payment_method_ids')
     def _compute_cash_control(self):
         for config in self: