[18.0][MIG] queue_job_batch, test_queue_job_batch: Migration to 18.0

queue_job_batch/README.rst

@@ -38,15 +38,13 @@ Example:
 .. code:: python
 
    from odoo import models, fields, api
-   from odoo.addons.queue_job.job import job
+
 
    class MyModel(models.Model):
-      _name = 'my.model'
+       _name = 'my.model'
 
-      @api.multi
-      @job
-      def my_method(self, a, k=None):
-          _logger.info('executed with a: %s and k: %s', a, k)
+       def my_method(self, a, k=None):
+           _logger.info('executed with a: %s and k: %s', a, k)
 
 
    class MyOtherModel(models.Model):
@@ -55,11 +53,9 @@ Example:
        @api.multi
        def button_do_stuff(self):
            batch = self.env['queue.job.batch'].get_new_batch('Group')
+           model = self.env['my.model'].with_context(job_batch=batch)
            for i in range(1, 100):
-               self.env['my.model'].with_context(
-                   job_batch=batch
-               ).with_delay().my_method('a', k=i)
-           batch.enqueue()
+               model.with_delay().my_method('a', k=i)
 
 In the snippet of code above, when we call ``button_do_stuff``, 100 jobs
 capturing the method and arguments will be postponed. It will be
@@ -101,16 +97,21 @@ Authors
 Contributors
 ------------
 
--  Enric Tobella <[email protected]>
+- Enric Tobella <[email protected]>
+
+- `Trobz <https://trobz.com>`__:
+
+  - Hoang Diep <[email protected]>
 
--  `Trobz <https://trobz.com>`__:
+- `ForgeFlow <https://forgeflow.com>`__:
 
-   -  Hoang Diep <[email protected]>
+  - Lois Rilo <[email protected]>
+  - Jasmin Solanki <[email protected]>
 
--  `ForgeFlow <https://forgeflow.com>`__:
+- `Camptocamp <https://camptocamp.com>`__:
 
-   -  Lois Rilo <lois.rilo@forgeflow.com>
-   -  Jasmin Solanki <jasmin.solanki@forgeflow.com>
+  - Maksym Yankin <maksym.yankin@camptocamp.com>
+  - Iván Todorovich <ivan.todorovich@camptocamp.com>
 
 Other credits
 -------------

queue_job_batch/__init__.py

@@ -1 +1,2 @@
+from . import controllers
 from . import models

queue_job_batch/__manifest__.py

@@ -4,7 +4,7 @@
 
 {
     "name": "Job Queue Batch",
-    "version": "16.0.1.0.1",
+    "version": "18.0.1.0.0",
     "author": "Creu Blanca,Odoo Community Association (OCA)",
     "website": "https://github.com/OCA/queue",
     "license": "AGPL-3",
@@ -25,9 +25,9 @@
     ],
     "assets": {
         "web.assets_backend": [
-            "queue_job_batch/static/src/js/*.js",
-            "queue_job_batch/static/src/scss/systray.scss",
-            "queue_job_batch/static/src/xml/*.xml",
+            "queue_job_batch/static/src/**/*.js",
+            "queue_job_batch/static/src/**/*.xml",
+            "queue_job_batch/static/src/**/*.scss",
         ],
     },
 }

queue_job_batch/controllers/__init__.py

@@ -0,0 +1 @@
+from . import webclient

queue_job_batch/controllers/webclient.py

@@ -0,0 +1,23 @@
+# Copyright 2025 Camptocamp SA (https://www.camptocamp.com).
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from odoo.http import request
+
+from odoo.addons.mail.controllers.webclient import WebclientController
+
+
+class WebClient(WebclientController):
+    def _process_request_for_internal_user(self, store, **kwargs):
+        res = super()._process_request_for_internal_user(store, **kwargs)
+        if kwargs.get("systray_get_queue_job_batches"):
+            # sudo: bus.bus: reading non-sensitive last id
+            bus_last_id = request.env["bus.bus"].sudo()._bus_last_id()
+            batches = request.env.user._get_queue_job_batches()
+            store.add(batches)
+            store.add(
+                {
+                    "queueJobBatchCounter": len(batches),
+                    "queueJobBatchCounterBusId": bus_last_id,
+                }
+            )
+        return res

queue_job_batch/migrations/18.0.1.0.0/pre-migrate.py

@@ -0,0 +1,19 @@
+# Copyright 2025 Camptocamp SA (https://www.camptocamp.com).
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+
+def migrate(cr, version):
+    cr.execute(
+        """
+        UPDATE queue_job_batch
+        SET state = 'pending'
+        WHERE state = 'draft'
+        """
+    )
+    cr.execute(
+        """
+        UPDATE queue_job_batch
+        SET is_read = FALSE
+        WHERE state != 'finished' AND is_read
+        """
+    )

queue_job_batch/models/__init__.py

@@ -1 +1,3 @@
-from . import queue_job, queue_job_batch
+from . import queue_job_batch
+from . import queue_job
+from . import res_users

queue_job_batch/models/queue_job.py

@@ -3,30 +3,30 @@
 
 from odoo import api, fields, models
 
+from odoo.addons.queue_job.job import identity_exact
+
 
 class QueueJob(models.Model):
     _inherit = "queue.job"
 
     job_batch_id = fields.Many2one("queue.job.batch")
 
-    @api.model
-    def create(self, vals):
+    @api.model_create_multi
+    def create(self, vals_list):
         batch = self.env.context.get("job_batch")
-        if batch and isinstance(batch, models.Model) and batch.state == "draft":
-            vals.update({"job_batch_id": batch.id})
-        return super().create(vals)
+        if batch and isinstance(batch, models.Model):
+            for vals in vals_list:
+                vals.update({"job_batch_id": batch.id})
+        return super().create(vals_list)
 
     def write(self, vals):
-        batches = self.env["queue.job.batch"]
-        for record in self:
-            if (
-                record.job_batch_id
-                and record.state != "done"
-                and vals.get("state", "") == "done"
-            ):
-                batches |= record.job_batch_id
-        for batch in batches:
-            # We need to make it with delay in order to prevent two jobs
-            # to work with the same batch
-            batch.with_delay().check_state()
+        if vals.get("state", "") == "done":
+            batches = self.env["queue.job.batch"]
+            for record in self:
+                if record.state != "done" and record.job_batch_id:
+                    batches |= record.job_batch_id
+            for batch in batches:
+                # We need to make it with delay in order to prevent two jobs
+                # to work with the same batch
+                batch.with_delay(identity_key=identity_exact).check_state()
         return super().write(vals)

queue_job_batch/models/queue_job_batch.py

@@ -4,6 +4,8 @@
 
 from odoo import api, fields, models
 
+from odoo.addons.mail.tools.discuss import Store
+
 
 class QueueJobBatch(models.Model):
     _name = "queue.job.batch"
@@ -32,12 +34,12 @@
     )
     state = fields.Selection(
         [
-            ("draft", "Draft"),
+            ("pending", "Pending"),
             ("enqueued", "Enqueued"),
             ("progress", "In Progress"),
             ("finished", "Finished"),
         ],
-        default="draft",
+        default="pending",
         required=True,
         readonly=True,
         tracking=True,
@@ -52,72 +54,75 @@
         "res.company",
         readonly=True,
     )
-    is_read = fields.Boolean(default=True)
+    is_read = fields.Boolean()
     completeness = fields.Float(
         compute="_compute_job_count",
     )
     failed_percentage = fields.Float(
         compute="_compute_job_count",
     )
 
-    def enqueue(self):
-        self.filtered(lambda r: r.state == "draft").write({"state": "enqueued"})
-        for record in self:
-            record.check_state()
+    def _get_state(self):
+        self.ensure_one()
+        job_states = set(self.job_ids.grouped("state").keys())
+        if all(state in ("done", "cancelled", "failed") for state in job_states):
+            return "finished"
+        elif {"done", "started"} & job_states:
+            return "progress"
+        elif "enqueued" in job_states:
+            return "enqueued"
+        return "pending"
 
     def check_state(self):
-        self.ensure_one()
-        if self.state == "enqueued" and any(
-            job.state not in ["pending", "enqueued"] for job in self.job_ids
-        ):
-            self.write({"state": "progress"})
-        if self.state != "progress":
-            return True
-        if all(job.state == "done" for job in self.job_ids):
-            self.write(
-                {
-                    "state": "finished",
-                    "is_read": False,
-                }
-            )
-        return True
+        for rec in self:
+            if (state := rec._get_state()) != rec.state:
+                rec.state = state
 
     def set_read(self):
-        res = self.write({"is_read": True})
-        notifications = []
-        channel = "queue.job.batch/updated"
-        notifications.append([self.env.user.partner_id, channel, {}])
-        self.env["bus.bus"]._sendmany(notifications)
-        return res
+        for rec in self:
+            if rec.is_read or rec.state != "finished":
+                continue
+            rec.is_read = True
+            rec.user_id._bus_send("queue.job.batch/updated", {"batch_read": True})
 
     @api.model
     def get_new_batch(self, name, **kwargs):
         vals = kwargs.copy()
-        company_id = self.env.user.company_id.id
-
-        if "company_id" in self.env.context:
-            company_id = self.env.context["company_id"]
-
         vals.update(
             {
                 "user_id": self.env.uid,
                 "name": name,
-                "state": "draft",
-                "company_id": company_id,
+                "company_id": self.env.company.id or self.env.user.company_id.id,
             }
         )
-        return self.sudo().create(vals).with_user(self.env.uid)
+        record = self.sudo().create(vals).with_user(self.env.uid)
+        record.user_id._bus_send("queue.job.batch/updated", {"batch_created": True})
+        return record
 
-    @api.depends("job_ids")
+    @api.depends("job_ids.state")
     def _compute_job_count(self):
-        for record in self:
-            job_count = len(record.job_ids)
-            failed_job_count = len(
-                record.job_ids.filtered(lambda r: r.state == "failed")
-            )
-            done_job_count = len(record.job_ids.filtered(lambda r: r.state == "done"))
-            record.job_count = job_count
-            record.finished_job_count = done_job_count
-            record.failed_job_count = failed_job_count
-            record.completeness = done_job_count / max(1, job_count)
-            record.failed_percentage = failed_job_count / max(1, job_count)
+        for rec in self:
+            jobs_by_state = rec.job_ids.grouped("state")
+            rec.job_count = len(rec.job_ids)
+            rec.failed_job_count = len(jobs_by_state.get("failed", []))
+            rec.finished_job_count = len(jobs_by_state.get("done", []))
+            rec.completeness = rec.finished_job_count / max(1, rec.job_count)
+            rec.failed_percentage = rec.failed_job_count / max(1, rec.job_count)
+
+    @api.model
+    def _to_store_fnames(self):
+        return (
+            "name",
+            "state",
+            "job_count",
+            "finished_job_count",
+            "failed_job_count",
+            "completeness",
+            "failed_percentage",
+        )
+
+    def _to_store(self, store: Store):
+        fnames = self._to_store_fnames()
+        for rec in self:
+            data = rec.read(fnames)[0]
+            store.add(rec, data)

queue_job_batch/models/res_users.py

@@ -0,0 +1,30 @@
+# Copyright 2025 Camptocamp SA (https://www.camptocamp.com).
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from odoo import models
+
+
+class Users(models.Model):
+    _name = "res.users"
+    _inherit = ["res.users"]
+
+    def _init_store_data(self, store):
+        res = super()._init_store_data(store)
+        store.add(
+            {
+                "hasQueueJobBatchUserGroup": self.env.user.has_group(
+                    "queue_job_batch.group_queue_job_batch_user"
+                ),
+            }
+        )
+        return res
+
+    def _get_queue_job_batches(self):
+        # See :meth:`controllers.webclient.WebClient._process_request_for_internal_user`
+        self.ensure_one()
+        return self.env["queue.job.batch"].search(
+            [
+                ("user_id", "=", self.id),
+                ("is_read", "=", False),
+            ]
+        )

queue_job_batch/readme/CONTRIBUTORS.md

@@ -6,3 +6,7 @@
 - [ForgeFlow](https://forgeflow.com):  
   - Lois Rilo \<<[email protected]>\>
   - Jasmin Solanki \<<[email protected]>\>
+
+- [Camptocamp](https://camptocamp.com):
+  - Maksym Yankin \<<[email protected]>\>
+  - Iván Todorovich \<<[email protected]>\>