[10.0][ADD] backport of report_async from Odoo 12

report_async/__manifest__.py

@@ -1,27 +1,23 @@
 # Copyright 2019 Ecosoft Co., Ltd (http://ecosoft.co.th/)
 # License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html)
 {
-    'name': 'Report Async',
-    'summary': 'Central place to run reports live or async',
-    'version': '12.0.1.0.1',
-    'author': 'Ecosoft, Odoo Community Association (OCA)',
-    'license': 'AGPL-3',
-    'website': 'https://github.com/OCA/reporting-engine',
-    'category': 'Generic Modules',
-    'depends': [
-        'queue_job',
+    "name": "Report Async",
+    "summary": "Central place to run reports live or async",
+    "version": "10.0.1.0.0",
+    "author": "Ecosoft, Odoo Community Association (OCA)",
+    "license": "AGPL-3",
+    "website": "https://github.com/OCA/reporting-engine",
+    "category": "Generic Modules",
+    "depends": ["queue_job"],
+    "data": [
+        "security/ir.model.access.csv",
+        "security/ir_rule.xml",
+        "data/mail_template.xml",
+        "views/report_async.xml",
+        "wizard/print_report_wizard.xml",
     ],
-    'data': [
-        'security/ir.model.access.csv',
-        'security/ir_rule.xml',
-        'data/mail_template.xml',
-        'views/report_async.xml',
-        'wizard/print_report_wizard.xml',
-    ],
-    'demo': [
-        'demo/report_async_demo.xml',
-    ],
-    'installable': True,
-    'maintainers': ['kittiu'],
-    'development_status': 'Beta',
+    "demo": ["demo/report_async_demo.xml"],
+    "installable": True,
+    "maintainers": ["kittiu"],
+    "development_status": "Beta",
 }

report_async/models/ir_report.py

@@ -5,24 +5,21 @@
 
 
 # Define all supported report_type
-REPORT_TYPES = ['qweb-pdf', 'qweb-text',
-                'qweb-xml', 'csv',
-                'excel', 'xlsx']
+REPORT_TYPES = ["qweb-pdf", "qweb-html"]
 
 
 class Report(models.Model):
-    _inherit = 'ir.actions.report'
+    _inherit = "report"
 
     @api.noguess
-    def report_action(self, docids, data=None, config=True):
-        res = super(Report, self).report_action(docids, data=data,
-                                                config=config)
-        if res['context'].get('async_process', False):
-            rpt_async_id = res['context']['active_id']
-            report_async = self.env['report.async'].browse(rpt_async_id)
-            if res['report_type'] in REPORT_TYPES:
+    def get_action(self, docids, report_name, data=None):
+        res = super(Report, self).get_action(docids, report_name, data=data)
+        if res["context"].get("async_process", False):
+            rpt_async_id = res["context"]["active_id"]
+            report_async = self.env["report.async"].browse(rpt_async_id)
+            if res["report_type"] in REPORT_TYPES:
                 report_async.with_delay().run_report(
-                    res['context'].get('active_ids', []), data,
-                    self.id, self._uid)
+                    res["context"].get("active_ids", []), data, self.id, self._uid
+                )
                 return {}
         return res

report_async/models/report_async.py

@@ -8,155 +8,155 @@
 from odoo.addons.queue_job.job import job
 
 
-# Define all supported report_type
-REPORT_TYPES_FUNC = {'qweb-pdf': 'render_qweb_pdf',
-                     'qweb-text': 'render_qweb_text',
-                     'qweb-xml': 'render_qweb_xml',
-                     'csv': 'render_csv',
-                     'excel': 'render_excel',
-                     'xlsx': 'render_xlsx', }
-
-
 class ReportAsync(models.Model):
-    _name = 'report.async'
-    _description = 'Report Async'
+    _name = "report.async"
+    _description = "Report Async"
 
     action_id = fields.Many2one(
-        comodel_name='ir.actions.act_window',
-        string='Reports',
-        required=True,
+        comodel_name="ir.actions.act_window", string="Reports", required=True
     )
     allow_async = fields.Boolean(
-        string='Allow Async',
+        string="Allow Async",
         default=False,
         help="This is not automatic field, please check if you want to allow "
         "this report in background process",
     )
-    name = fields.Char(
-        string='Name',
-        related='action_id.display_name',
-    )
+    name = fields.Char(string="Name", related="action_id.display_name")
     email_notify = fields.Boolean(
-        string='Email Notification',
+        string="Email Notification",
         help="Send email with link to report, when it is ready",
     )
     group_ids = fields.Many2many(
-        string='Groups',
-        comodel_name='res.groups',
+        string="Groups",
+        comodel_name="res.groups",
         help="Only user in selected groups can use this report."
         "If left blank, everyone can use",
     )
     job_ids = fields.Many2many(
-        comodel_name='queue.job',
-        compute='_compute_job',
+        comodel_name="queue.job",
+        compute="_compute_job",
         help="List all jobs related to this running report",
     )
     job_status = fields.Selection(
-        selection=[('pending', 'Pending'),
-                   ('enqueued', 'Enqueued'),
-                   ('started', 'Started'),
-                   ('done', 'Done'),
-                   ('failed', 'Failed')],
-        compute='_compute_job',
+        selection=[
+            ("pending", "Pending"),
+            ("enqueued", "Enqueued"),
+            ("started", "Started"),
+            ("done", "Done"),
+            ("failed", "Failed"),
+        ],
+        compute="_compute_job",
         help="Latest Job Status",
     )
-    job_info = fields.Text(
-        compute='_compute_job',
-        help="Latest Job Error Message",
-    )
+    job_info = fields.Text(compute="_compute_job", help="Latest Job Error Message")
     file_ids = fields.Many2many(
-        comodel_name='ir.attachment',
-        compute='_compute_file',
+        comodel_name="ir.attachment",
+        compute="_compute_file",
         help="List all files created by this report background process",
     )
 
     @api.multi
     def _compute_job(self):
         for rec in self:
-            rec.job_ids = self.sudo().env['queue.job'].search(
-                [('func_string', 'like', 'report.async(%s,)' % rec.id),
-                 ('user_id', '=', self._uid)],
-                order='id desc')
-            rec.job_status = (rec.job_ids[0].sudo().state
-                              if rec.job_ids else False)
-            rec.job_info = (rec.job_ids[0].sudo().exc_info
-                            if rec.job_ids else False)
+            rec.job_ids = (
+                self.sudo()
+                .env["queue.job"]
+                .search(
+                    [
+                        ("func_string", "like", "report.async(%s,)" % rec.id),
+                        ("user_id", "=", self._uid),
+                    ],
+                    order="id desc",
+                )
+            )
+            rec.job_status = rec.job_ids[0].sudo().state if rec.job_ids else False
+            rec.job_info = rec.job_ids[0].sudo().exc_info if rec.job_ids else False
 
     @api.multi
     def _compute_file(self):
-        files = self.env['ir.attachment'].search(
-            [('res_model', '=', 'report.async'),
-             ('res_id', 'in', self.ids),
-             ('create_uid', '=', self._uid)],
-            order='id desc')
+        files = self.env["ir.attachment"].search(
+            [
+                ("res_model", "=", "report.async"),
+                ("res_id", "in", self.ids),
+                ("create_uid", "=", self._uid),
+            ],
+            order="id desc",
+        )
         for rec in self:
             rec.file_ids = files.filtered(lambda l: l.res_id == rec.id)
 
     def run_now(self):
         self.ensure_one()
         action = self.env.ref(self.action_id.xml_id)
         result = action.read()[0]
-        ctx = safe_eval(result.get('context', {}))
-        ctx.update({'async_process': False})
-        result['context'] = ctx
+        ctx = safe_eval(result.get("context", {}))
+        ctx.update({"async_process": False})
+        result["context"] = ctx
         return result
 
     @api.multi
     def run_async(self):
         self.ensure_one()
         if not self.allow_async:
-            raise UserError(_('Background process not allowed.'))
+            raise UserError(_("Background process not allowed."))
         action = self.env.ref(self.action_id.xml_id)
         result = action.read()[0]
-        ctx = safe_eval(result.get('context', {}))
-        ctx.update({'async_process': True})
-        result['context'] = ctx
+        ctx = safe_eval(result.get("context", {}))
+        ctx.update({"async_process": True})
+        result["context"] = ctx
         return result
 
     @api.multi
     def view_files(self):
         self.ensure_one()
-        action = self.env.ref('report_async.action_view_files')
+        action = self.env.ref("report_async.action_view_files")
         result = action.read()[0]
-        result['domain'] = [('id', 'in', self.file_ids.ids)]
+        result["domain"] = [("id", "in", self.file_ids.ids)]
         return result
 
     @api.multi
     def view_jobs(self):
         self.ensure_one()
-        action = self.env.ref('queue_job.action_queue_job')
+        action = self.env.ref("queue_job.action_queue_job")
         result = action.read()[0]
-        result['domain'] = [('id', 'in', self.job_ids.ids)]
-        result['context'] = {}
+        result["domain"] = [("id", "in", self.job_ids.ids)]
+        result["context"] = {}
         return result
 
     @api.model
     @job
     def run_report(self, docids, data, report_id, user_id):
-        report = self.env['ir.actions.report'].browse(report_id)
-        func = REPORT_TYPES_FUNC[report.report_type]
-        # Run report
-        out_file, file_ext = getattr(report, func)(docids, data)
+        report = self.env["ir.actions.report.xml"].browse(report_id)
+        # Render report
+        out_file = self.env["report"].render(report.report_name)
         out_file = base64.b64encode(out_file)
-        out_name = '%s.%s' % (report.name, file_ext)
+        file_ext = report.report_type.replace("qweb-", "")
+        out_name = "%s.%s" % (report.name, file_ext)
         # Save report to attachment
-        attachment = self.env['ir.attachment'].sudo().create({
-            'name': out_name,
-            'datas': out_file,
-            'datas_fname': out_name,
-            'type': 'binary',
-            'res_model': 'report.async',
-            'res_id': self.id,
-        })
-        self._cr.execute("""
+        attachment = (
+            self.env["ir.attachment"]
+            .sudo()
+            .create(
+                {
+                    "name": out_name,
+                    "datas": out_file,
+                    "datas_fname": out_name,
+                    "type": "binary",
+                    "res_model": "report.async",
+                    "res_id": self.id,
+                }
+            )
+        )
+        self._cr.execute(
+            """
             UPDATE ir_attachment SET create_uid = %s, write_uid = %s
-            WHERE id = %s""", (self._uid, self._uid, attachment.id))
+            WHERE id = %s""",
+            (self._uid, self._uid, attachment.id),
+        )
         # Send email
         if self.email_notify:
             self._send_email(attachment)
 
     def _send_email(self, attachment):
-        template = self.env.ref('report_async.async_report_delivery')
-        template.send_mail(attachment.id,
-                           notif_layout='mail.mail_notification_light',
-                           force_send=False)
+        template = self.env.ref("report_async.async_report_delivery")
+        template.send_mail(attachment.id, force_send=False)

report_async/tests/test_report_async.py

@@ -1,47 +1,48 @@
 # Copyright 2019 Ecosoft Co., Ltd (http://ecosoft.co.th/)
 # License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html)
 from odoo.tests import common
-from odoo.tests.common import Form
 from odoo.exceptions import UserError
 
 
 class TestJobChannel(common.TransactionCase):
-
     def setUp(self):
         super(TestJobChannel, self).setUp()
-        self.print_doc = self.env.ref('report_async.'
-                                      'report_async_print_document')
-        self.test_rec = self.env.ref('base.module_mail')
-        self.test_rpt = self.env.ref('base.ir_module_reference_print')
+        self.print_doc = self.env.ref("report_async." "report_async_print_document")
+        self.test_rec = self.env.ref("base.module_mail")
+        self.test_rpt = self.env.ref("base.ir_module_reference_print")
 
     def _print_wizard(self, res):
-        obj = self.env[res['res_model']]
-        ctx = {'active_model': self.print_doc._name,
-               'active_id': self.print_doc.id, }
-        ctx.update(res['context'])
-        with Form(obj.with_context(ctx)) as form:
-            form.reference = '%s,%s' % (self.test_rec._name, self.test_rec.id)
-            form.action_report_id = self.test_rpt
-        print_wizard = form.save()
+        obj = self.env[res["res_model"]]
+        ctx = {"active_model": self.print_doc._name, "active_id": self.print_doc.id}
+        ctx.update(res["context"])
+        print_wizard = (
+            self.env["print.report.wizard"]
+            .with_context(ctx)
+            .create(
+                {
+                    "reference": "%s,%s" % (self.test_rec._name, self.test_rec.id),
+                    "action_report_id": self.test_rpt.id,
+                }
+            )
+        )
         return print_wizard
 
     def test_1_run_now(self):
         """Run now will return report action as normal"""
         res = self.print_doc.run_now()
         report_action = self._print_wizard(res).print_report()
-        self.assertEquals(report_action['type'], 'ir.actions.report')
+        self.assertEquals(report_action["type"], "ir.actions.report.xml")
 
     def test_2_run_async(self):
         """Run background will return nothing, job started"""
         with self.assertRaises(UserError):
             self.print_doc.run_async()
-        self.print_doc.write({'allow_async': True,
-                              'email_notify': True})
+        self.print_doc.write({"allow_async": True, "email_notify": True})
         res = self.print_doc.run_async()
         print_wizard = self._print_wizard(res)
         report_action = print_wizard.print_report()
         self.assertEquals(report_action, {})  # Do not run report yet
-        self.assertEquals(self.print_doc.job_status, 'pending')  # Job started
+        self.assertEquals(self.print_doc.job_status, "pending")  # Job started
         # Test produce file (as queue will not run in test mode)
         docids = [print_wizard.reference.id]
         data = None

report_async/views/report_async.xml

@@ -109,7 +109,6 @@
 
     <menuitem
         id="menu_report_async"
-        parent="base.menu_board_root"
         action="action_report_async"
         sequence="10"/>