[MIG] report_fillpdf: Migration to 16.0

Author: cvinh

report_fillpdf/__manifest__.py

@@ -7,7 +7,7 @@
     "author": "Creu Blanca," "Odoo Community Association (OCA)",
     "website": "https://github.com/OCA/reporting-engine",
     "category": "Reporting",
-    "version": "14.0.1.0.1",
+    "version": "16.0.1.0.1",
     "license": "AGPL-3",
     "external_dependencies": {
         "python": [
@@ -21,11 +21,14 @@
         "base",
         "web",
     ],
-    "data": [
-        "views/webclient_templates.xml",
-    ],
+    "data": [],
     "demo": [
         "demo/report.xml",
     ],
     "installable": True,
+    "assets": {
+        "web.assets_backend": [
+            "report_fillpdf/static/src/js/report/action_manager_report.esm.js",
+        ],
+    },
 }

report_fillpdf/controllers/main.py

@@ -2,13 +2,25 @@
 # License AGPL-3.0 or later (https://www.gnuorg/licenses/agpl.html).
 
 import json
+import logging
 
-from odoo.http import content_disposition, request, route
+from werkzeug.urls import url_decode
 
-from odoo.addons.web.controllers import main as report
+from odoo.http import (
+    content_disposition,
+    request,
+    route,
+    serialize_exception as _serialize_exception,
+)
+from odoo.tools import html_escape
+from odoo.tools.safe_eval import safe_eval, time
 
+from odoo.addons.web.controllers.report import ReportController
 
-class ReportController(report.ReportController):
+_logger = logging.getLogger(__name__)
+
+
+class ReportController(ReportController):
     @route()
     def report_routes(self, reportname, docids=None, converter=None, **data):
         if converter == "fillpdf":
@@ -19,23 +31,69 @@ def report_routes(self, reportname, docids=None, converter=None, **data):
             if data.get("options"):
                 data.update(json.loads(data.pop("options")))
             if data.get("context"):
-                # Ignore 'lang' here, because the context in data is the one
-                # from the webclient *but* if the user explicitely wants to
-                # change the lang, this mechanism overwrites it.
                 data["context"] = json.loads(data["context"])
-                if data["context"].get("lang"):
-                    del data["context"]["lang"]
                 context.update(data["context"])
-            pdf = report.with_context(context).render_fillpdf(docids, data=data)[0]
+            pdf = report.with_context(**context).render_fillpdf(
+                reportname, docids, data=data
+            )[0]
             pdfhttpheaders = [
                 ("Content-Type", "application/pdf"),
                 ("Content-Length", len(pdf)),
-                (
-                    "Content-Disposition",
-                    content_disposition(report.report_file + ".pdf"),
-                ),
             ]
             return request.make_response(pdf, headers=pdfhttpheaders)
-        return super(ReportController, self).report_routes(
-            reportname, docids, converter, **data
-        )
+        return super().report_routes(reportname, docids, converter, **data)
+
+    @route()
+    def report_download(self, data, context=None, token=None):
+        requestcontent = json.loads(data)
+        url, report_type = requestcontent[0], requestcontent[1]
+        if report_type == "fillpdf":
+            try:
+                reportname = url.split("/report/fillpdf/")[1].split("?")[0]
+                docids = None
+                if "/" in reportname:
+                    reportname, docids = reportname.split("/")
+                if docids:
+                    # Generic report:
+                    response = self.report_routes(
+                        reportname, docids=docids, converter="fillpdf", context=context
+                    )
+                else:
+                    # Particular report:
+                    data = dict(
+                        url_decode(url.split("?")[1]).items()
+                    )  # decoding the args represented in JSON
+                    if "context" in data:
+                        context, data_context = json.loads(context or "{}"), json.loads(
+                            data.pop("context")
+                        )
+                        context = json.dumps({**context, **data_context})
+                    response = self.report_routes(
+                        reportname, converter="fillpdf", context=context, **data
+                    )
+
+                report = request.env["ir.actions.report"]._get_report_from_name(
+                    reportname
+                )
+                filename = "%s.%s" % (report.name, "pdf")
+
+                if docids:
+                    ids = [int(x) for x in docids.split(",")]
+                    obj = request.env[report.model].browse(ids)
+                    if report.print_report_name and not len(obj) > 1:
+                        report_name = safe_eval(
+                            report.print_report_name, {"object": obj, "time": time}
+                        )
+                        filename = "%s.%s" % (report_name, "pdf")
+                if not response.headers.get("Content-Disposition"):
+                    response.headers.add(
+                        "Content-Disposition", content_disposition(filename)
+                    )
+                return response
+            except Exception as e:
+                _logger.exception("Error while generating report %s", reportname)
+                se = _serialize_exception(e)
+                error = {"code": 200, "message": "Odoo Server Error", "data": se}
+                return request.make_response(html_escape(json.dumps(error)))
+        else:
+            return super().report_download(data, context=context, token=token)

report_fillpdf/demo/report.xml

@@ -1,16 +1,14 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <odoo>
     <!--
-    © 2017 Creu Blanca
-    License AGPL-3.0 or later (https://www.gnuorg/licenses/agpl.html).
+        © 2017 Creu Blanca
+        License AGPL-3.0 or later (https://www.gnuorg/licenses/agpl.html).
     -->
-    <report
-        id="partner_fillpdf"
-        model="res.partner"
-        string="Fill PDF"
-        report_type="fillpdf"
-        name="report_fillpdf.partner_fillpdf"
-        file="res_partner"
-        attachment_use="False"
-    />
+    <record model="ir.actions.report" id="partner_fillpdf">
+        <field name="name">report_fillpdf.partner_fillpdf</field>
+        <field name="model">res.partner</field>
+        <field name="report_type">fillpdf</field>
+        <field name="report_name">report_fillpdf.partner_fillpdf</field>
+        <field name="report_file">res_partner</field>
+    </record>
 </odoo>

report_fillpdf/models/ir_report.py

@@ -1,11 +1,13 @@
 # Copyright 2017 Creu Blanca
 # License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
 
+import io
 import logging
 from collections import OrderedDict
 
 from odoo import _, api, fields, models
-from odoo.exceptions import UserError
+from odoo.exceptions import AccessError, UserError
+from odoo.tools.safe_eval import safe_eval, time
 
 _logger = logging.getLogger(__name__)
 
@@ -18,58 +20,127 @@ class ReportAction(models.Model):
     )
 
     @api.model
-    def render_fillpdf(self, docids, data):
-        # Here we add pdf attachment support
-        self_sudo = self.sudo()
-        save_in_attachment = OrderedDict()
-        # Maps the streams in `save_in_attachment` back to the records they came from
-        stream_record = dict()
+    def _render_fillpdf_stream(self, report_ref, docids, data):
+        report_sudo = self._get_report(report_ref)
+        collected_streams = OrderedDict()
+
+        # Fetch the existing attachments from the database for later use.
+        # Reload the stream from the attachment in case of 'attachment_use'.
         if docids:
-            # Dispatch the records by ones having an attachment and ones requesting a call to
-            # fillpdf.
-            Model = self.env[self_sudo.model]
-            record_ids = Model.browse(docids)
-            fp_record_ids = Model
-            if self_sudo.attachment:
-                for record_id in record_ids:
-                    attachment = self_sudo.retrieve_attachment(record_id)
-                    if attachment:
-                        stream = self_sudo._retrieve_stream_from_attachment(attachment)
-                        save_in_attachment[record_id.id] = stream
-                        stream_record[stream] = record_id
-                    if not self_sudo.attachment_use or not attachment:
-                        fp_record_ids += record_id
-
-            else:
-                fp_record_ids = record_ids
-            docids = fp_record_ids.ids
-
-        if save_in_attachment and not docids:
-            _logger.info("The PDF report has been generated from attachments.")
-            self._raise_on_unreadable_pdfs(save_in_attachment.values(), stream_record)
-            return self_sudo._post_pdf(save_in_attachment), "pdf"
-
-        # We generate pdf with fillpdf
-        report_model_name = "report.%s" % self.report_name
-        report_model = self.env.get(report_model_name)
-        if report_model is None:
-            raise UserError(_("%s model was not found" % report_model_name))
-
-        pdf_content = report_model.with_context(
-            {"active_model": self.model}
-        ).fill_report(docids, data)
+            records = self.env[report_sudo.model].browse(docids)
+            for record in records:
+                stream = None
+                attachment = None
+                if report_sudo.attachment:
+                    attachment = report_sudo.retrieve_attachment(record)
+
+                    # If existing attachement, extract the stream from the attachment.
+                    if attachment and report_sudo.attachment_use:
+                        stream = io.BytesIO(attachment.raw)
+
+                    # If no attachment, generate the pdf
+                    else:
+                        report_model_name = "report.%s" % self.report_name
+                        report_model = self.env.get(report_model_name)
+                        if report_model is None:
+                            raise UserError(
+                                _("%s model was not found") % report_model_name
+                            )
+
+                        stream = io.BytesIO(
+                            report_model.with_context(
+                                **{"active_model": self.model}
+                            ).fill_report(docids, data)
+                        )
+                        _logger.info(
+                            "The PDF report has been generated for model: %s, records %s."
+                            % (report_model, str(docids))
+                        )
+
+                collected_streams[record.id] = {
+                    "stream": stream,
+                    "attachment": attachment,
+                }
+        return collected_streams
+
+    @api.model
+    def render_fillpdf(self, report_ref, docids, data):
+        report_sudo = self._get_report(report_ref)
+        collected_streams = self._render_fillpdf_stream(report_ref, docids, data)
+
+        if report_sudo.attachment:
+            attachment_vals_list = []
+            for res_id, stream_data in collected_streams.items():
+                # An attachment already exists.
+                if stream_data["attachment"]:
+                    continue
+
+                # if res_id is false
+                # we are unable to fetch the record,
+                # it won't be saved as we can't split the documents unambiguously
+                if not res_id:
+                    _logger.warning(
+                        "These documents were not saved as an attachment\
+                        because the template of %s doesn't "
+                        "have any headers seperating different instances\
+                        of it. If you want it saved,"
+                        "please print the documents separately",
+                        report_sudo.report_name,
+                    )
+                    continue
+                record = self.env[report_sudo.model].browse(res_id)
+                attachment_name = safe_eval(
+                    report_sudo.attachment, {"object": record, "time": time}
+                )
+
+                # Unable to compute a name for the attachment.
+                if not attachment_name:
+                    continue
+
+                attachment_vals_list.append(
+                    {
+                        "name": attachment_name,
+                        "raw": stream_data["stream"].getvalue(),
+                        "res_model": report_sudo.model,
+                        "res_id": record.id,
+                        "type": "binary",
+                    }
+                )
+
+            if attachment_vals_list:
+                attachment_names = ", ".join(x["name"] for x in attachment_vals_list)
+                try:
+                    self.env["ir.attachment"].create(attachment_vals_list)
+                except AccessError:
+                    _logger.info(
+                        "Cannot save PDF report %r attachments for user %r",
+                        attachment_names,
+                        self.env.user.display_name,
+                    )
+                else:
+                    _logger.info(
+                        "The PDF documents %r are now saved in the database",
+                        attachment_names,
+                    )
+
+        # Merge all streams together for a single record.
+        streams_to_merge = [
+            x["stream"] for x in collected_streams.values() if x["stream"]
+        ]
+        if len(streams_to_merge) == 1:
+            pdf_content = streams_to_merge[0].getvalue()
+        else:
+            with self._merge_pdfs(streams_to_merge) as pdf_merged_stream:
+                pdf_content = pdf_merged_stream.getvalue()
+
+        for stream in streams_to_merge:
+            stream.close()
 
         if docids:
-            self._raise_on_unreadable_pdfs(save_in_attachment.values(), stream_record)
             _logger.info(
-                "The PDF report has been generated for model: %s, records %s."
-                % (self_sudo.model, str(docids))
-            )
-            return (
-                self_sudo._post_pdf(
-                    save_in_attachment, pdf_content=pdf_content, res_ids=docids
-                ),
-                "pdf",
+                "The PDF report has been generated for model: %s, records %s.",
+                report_sudo.model,
+                str(docids),
             )
 
         return pdf_content, "pdf"
@@ -86,4 +157,4 @@ def _get_report_from_name(self, report_name):
             ("report_name", "=", report_name),
         ]
         context = self.env["res.users"].context_get()
-        return report_obj.with_context(context).search(conditions, limit=1)
+        return report_obj.with_context(**context).search(conditions, limit=1)