odoo-addon-base-report-to-printer 18.0.1.1.6__py3-none-any.whl

odoo/addons/base_report_to_printer/models/__init__.py

@@ -0,0 +1,8 @@
+from . import ir_actions_report
+from . import printing_action
+from . import printing_job
+from . import printing_printer
+from . import printing_server
+from . import printing_report_xml_action
+from . import printing_tray
+from . import res_users

odoo/addons/base_report_to_printer/models/ir_actions_report.py

@@ -0,0 +1,253 @@
+# Copyright (c) 2007 Ferran Pegueroles <ferran@pegueroles.com>
+# Copyright (c) 2009 Albert Cervera i Areny <albert@nan-tic.com>
+# Copyright (C) 2011 Agile Business Group sagl (<http://www.agilebg.com>)
+# Copyright (C) 2011 Domsense srl (<http://www.domsense.com>)
+# Copyright (C) 2013-2014 Camptocamp (<http://www.camptocamp.com>)
+# Copyright 2024 Tecnativa - Sergio Teruel
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+import threading
+from time import time
+
+from odoo import _, api, exceptions, fields, models, registry
+from odoo.tools.safe_eval import safe_eval
+
+REPORT_TYPES = {"qweb-pdf": "pdf", "qweb-text": "text"}
+
+
+class IrActionsReport(models.Model):
+    _inherit = "ir.actions.report"
+
+    property_printing_action_id = fields.Many2one(
+        comodel_name="printing.action",
+        string="Default Behaviour",
+        company_dependent=True,
+    )
+    printing_printer_id = fields.Many2one(
+        comodel_name="printing.printer", string="Default Printer"
+    )
+    printer_tray_id = fields.Many2one(
+        comodel_name="printing.tray",
+        string="Paper Source",
+        domain="[('printer_id', '=', printing_printer_id)]",
+    )
+    printing_action_ids = fields.One2many(
+        comodel_name="printing.report.xml.action",
+        inverse_name="report_id",
+        string="Actions",
+        help="This field allows configuring action and printer on a per user basis",
+    )
+
+    @api.onchange("printing_printer_id")
+    def onchange_printing_printer_id(self):
+        """Reset the tray when the printer is changed"""
+        self.printer_tray_id = False
+
+    @api.model
+    def print_action_for_report_name(self, report_name):
+        """Returns if the action is a direct print or pdf
+
+        Called from js
+        """
+        report = self._get_report_from_name(report_name)
+        if not report:
+            return {}
+        result = report.behaviour()
+        serializable_result = {
+            "action": result["action"],
+            "printer_name": result["printer"].name,
+        }
+        if result.get("printer_exception") and not self.env.context.get(
+            "skip_printer_exception"
+        ):
+            serializable_result["printer_exception"] = True
+        if self.env.context.get("force_print_to_client"):
+            serializable_result["action"] = "client"
+        return serializable_result
+
+    def _get_user_default_printer(self, user):
+        return user.printing_printer_id
+
+    def _get_user_default_print_behaviour(self):
+        printer_obj = self.env["printing.printer"]
+        user = self.env.user
+        printer = self._get_user_default_printer(user)
+        return dict(
+            action=user.printing_action or "client",
+            printer=printer or printer_obj.get_default(),
+            tray=(
+                str(user.printer_tray_id.system_name) if user.printer_tray_id else False
+            ),
+        )
+
+    def _get_report_default_print_behaviour(self):
+        result = {}
+        report_action = self.property_printing_action_id
+        if report_action and report_action.action_type != "user_default":
+            result["action"] = report_action.action_type
+        if self.printing_printer_id:
+            result["printer"] = self.printing_printer_id
+        if self.printer_tray_id:
+            result["tray"] = self.printer_tray_id.system_name
+        return result
+
+    def behaviour(self):
+        self.ensure_one()
+        printing_act_obj = self.env["printing.report.xml.action"]
+
+        result = self._get_user_default_print_behaviour()
+        result.update(self._get_report_default_print_behaviour())
+
+        # Retrieve report-user specific values
+        print_action = printing_act_obj.search(
+            [
+                ("report_id", "=", self.id),
+                ("user_id", "=", self.env.uid),
+                ("action", "!=", "user_default"),
+            ],
+            limit=1,
+        )
+        if print_action:
+            # For some reason design takes report defaults over
+            # False action entries so we must allow for that here
+            result.update({k: v for k, v in print_action.behaviour().items() if v})
+        printer = result.get("printer")
+        if printer:
+            # When no printer is available we can fallback to the default behavior
+            # letting the user to manually print the reports.
+            try:
+                printer.server_id._open_connection(raise_on_error=True)
+                printer_exception = printer.status in [
+                    "error",
+                    "server-error",
+                    "unavailable",
+                ]
+            except Exception:
+                printer_exception = True
+            if printer_exception and not self.env.context.get("skip_printer_exception"):
+                result["printer_exception"] = True
+        return result
+
+    def print_document_client_action(self, record_ids, data=None):
+        behaviour = self.behaviour()
+        printer = behaviour.pop("printer", None)
+        if printer.multi_thread:
+
+            @self.env.cr.postcommit.add
+            def _launch_print_thread():
+                threaded_calculation = threading.Thread(
+                    target=self.print_document_threaded,
+                    args=(self.id, record_ids, data),
+                )
+                threaded_calculation.start()
+
+            return True
+        else:
+            try:
+                return self.print_document(record_ids, data=data)
+            except Exception:
+                return
+
+    def print_document_threaded(self, report_id, record_ids, data):
+        with registry(self._cr.dbname).cursor() as cr:
+            self = self.with_env(self.env(cr=cr))
+            report = self.env["ir.actions.report"].browse(report_id)
+            report.print_document(record_ids, data)
+
+    def print_document(self, record_ids, data=None):
+        """Print a document, do not return the document file"""
+        report_type = REPORT_TYPES.get(self.report_type)
+        if not report_type:
+            raise exceptions.UserError(
+                _("This report type (%s) is not supported by direct printing!")
+                % str(self.report_type)
+            )
+        method_name = f"_render_qweb_{report_type}"
+        document, doc_format = getattr(
+            self.with_context(must_skip_send_to_printer=True), method_name
+        )(self.report_name, record_ids, data=data)
+        behaviour = self.behaviour()
+        printer = behaviour.pop("printer", None)
+
+        if not printer:
+            raise exceptions.UserError(_("No printer configured to print this report."))
+        if self.print_report_name:
+            report_file_names = [
+                safe_eval(self.print_report_name, {"object": obj, "time": time})
+                for obj in self.env[self.model].browse(record_ids)
+            ]
+            title = " ".join(report_file_names)
+            if len(title) > 80:
+                title = title[:80] + "…"
+        else:
+            title = self.report_name
+        behaviour["title"] = title
+        behaviour["res_ids"] = record_ids
+        # TODO should we use doc_format instead of report_type
+        return printer.print_document(
+            self, document, doc_format=self.report_type, **behaviour
+        )
+
+    def _can_print_report(self, behaviour, printer, document):
+        """Predicate that decide if report can be sent to printer
+
+        If you want to prevent `render_qweb_pdf` to send report you can set
+        the `must_skip_send_to_printer` key to True in the context
+        """
+        if self.env.context.get("must_skip_send_to_printer"):
+            return False
+        if (
+            behaviour["action"] == "server"
+            and printer
+            and document
+            and not behaviour.get("printer_exception")
+        ):
+            return True
+        return False
+
+    def report_action(self, docids, data=None, config=True):
+        res = super().report_action(docids, data=data, config=config)
+        if not res.get("id"):
+            res["id"] = self.id
+        return res
+
+    def _render_qweb_pdf(self, report_ref, res_ids=None, data=None):
+        """Generate a PDF and returns it.
+
+        If the action configured on the report is server, it prints the
+        generated document as well.
+        """
+        document, doc_format = super()._render_qweb_pdf(
+            report_ref, res_ids=res_ids, data=data
+        )
+        report = self._get_report(report_ref)
+        behaviour = report.behaviour()
+        printer = behaviour.pop("printer", None)
+        can_print_report = report._can_print_report(behaviour, printer, document)
+
+        if can_print_report:
+            printer.print_document(
+                report, document, doc_format=report.report_type, **behaviour
+            )
+
+        return document, doc_format
+
+    def _render_qweb_text(self, report_ref, docids, data=None):
+        """Generate a TEXT file and returns it.
+
+        If the action configured on the report is server, it prints the
+        generated document as well.
+        """
+        document, doc_format = super()._render_qweb_text(
+            report_ref, docids=docids, data=data
+        )
+        report = self._get_report(report_ref)
+        behaviour = report.behaviour()
+        printer = behaviour.pop("printer", None)
+        can_print_report = report._can_print_report(behaviour, printer, document)
+
+        if can_print_report:
+            printer.print_document(
+                report, document, doc_format=report.report_type, **behaviour
+            )
+
+        return document, doc_format

odoo/addons/base_report_to_printer/models/printing_action.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2007 Ferran Pegueroles <ferran@pegueroles.com>
+# Copyright (c) 2009 Albert Cervera i Areny <albert@nan-tic.com>
+# Copyright (C) 2011 Agile Business Group sagl (<http://www.agilebg.com>)
+# Copyright (C) 2011 Domsense srl (<http://www.domsense.com>)
+# Copyright (C) 2013-2014 Camptocamp (<http://www.camptocamp.com>)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class PrintingAction(models.Model):
+    _name = "printing.action"
+    _description = "Print Job Action"
+
+    @property
+    def _available_action_types(self):
+        return [
+            ("server", "Send to Printer"),
+            ("client", "Send to Client"),
+            ("user_default", "Use user's defaults"),
+        ]
+
+    name = fields.Char(required=True)
+    action_type = fields.Selection(
+        selection=_available_action_types, string="Type", required=True
+    )

odoo/addons/base_report_to_printer/models/printing_job.py

@@ -0,0 +1,131 @@
+# Copyright (C) 2016 SYLEAM (<http://www.syleam.fr>)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+import logging
+
+from odoo import fields, models
+
+_logger = logging.getLogger(__name__)
+
+
+class PrintingJob(models.Model):
+    _name = "printing.job"
+    _description = "Printing Job"
+    _order = "job_id_cups DESC"
+
+    name = fields.Char(help="Job name.")
+    active = fields.Boolean(
+        default=True, help="Unchecked if the job is purged from CUPS."
+    )
+    job_id_cups = fields.Integer(
+        string="Job ID", required=True, help="CUPS id for this job."
+    )
+    server_id = fields.Many2one(
+        comodel_name="printing.server",
+        string="Server",
+        related="printer_id.server_id",
+        store=True,
+        help="Server which hosts this job.",
+    )
+    printer_id = fields.Many2one(
+        comodel_name="printing.printer",
+        string="Printer",
+        required=True,
+        ondelete="cascade",
+        help="Printer used for this job.",
+    )
+    job_media_progress = fields.Integer(
+        string="Media Progress",
+        required=True,
+        help="Percentage of progress for this job.",
+    )
+    time_at_creation = fields.Datetime(
+        string="Creation Date",
+        required=True,
+        help="Date and time of creation of this job.",
+    )
+    time_at_processing = fields.Datetime(
+        string="Processing Date", help="Date and time of process for this job."
+    )
+    time_at_completed = fields.Datetime(
+        string="Completion Date", help="Date and time of completion for this job."
+    )
+    job_state = fields.Selection(
+        selection=[
+            ("pending", "Pending"),
+            ("pending held", "Pending Held"),
+            ("processing", "Processing"),
+            ("processing stopped", "Processing Stopped"),
+            ("canceled", "Canceled"),
+            ("aborted", "Aborted"),
+            ("completed", "Completed"),
+            ("unknown", "Unknown"),
+        ],
+        string="State",
+        help="Current state of the job.",
+    )
+    job_state_reason = fields.Selection(
+        selection=[
+            ("none", "No reason"),
+            ("aborted-by-system", "Aborted by the system"),
+            ("compression-error", "Error in the compressed data"),
+            ("cups-filter-crashed", "CUPS filter crashed"),
+            ("document-access-error", "The URI cannot be accessed"),
+            ("document-format-error", "Error in the document"),
+            ("job-canceled-at-device", "Cancelled at the device"),
+            ("job-canceled-by-operator", "Cancelled by the printer operator"),
+            ("job-canceled-by-user", "Cancelled by the user"),
+            ("job-completed-successfully", "Completed successfully"),
+            ("job-completed-with-errors", "Completed with some errors"),
+            ("job-completed-with-warnings", "Completed with some warnings"),
+            ("job-data-insufficient", "No data has been received"),
+            ("job-hold-until-specified", "Currently held"),
+            ("job-incoming", "Files are currently being received"),
+            ("job-interpreting", "Currently being interpreted"),
+            ("job-outgoing", "Currently being sent to the printer"),
+            ("job-printing", "Currently printing"),
+            ("job-queued", "Queued for printing"),
+            ("job-queued-for-marker", "Printer needs ink/marker/toner"),
+            ("job-restartable", "Can be restarted"),
+            ("job-transforming", "Being transformed into a different format"),
+            ("printer-stopped", "Printer is stopped"),
+            ("printer-stopped-partly", "Printer state reason set to 'stopped-partly'"),
+            (
+                "processing-to-stop-point",
+                "Cancelled, but printing already processed pages",
+            ),
+            ("queued-in-device", "Queued at the output device"),
+            ("resources-are-not-ready", "Resources not available to print the job"),
+            ("service-off-line", "Held because the printer is offline"),
+            ("submission-interrupted", "Files were not received in full"),
+            ("unsupported-compression", "Compressed using an unknown algorithm"),
+            ("unsupported-document-format", "Unsupported format"),
+        ],
+        string="State Reason",
+        help="Reason for the current job state.",
+    )
+
+    _sql_constraints = [
+        (
+            "job_id_cups_unique",
+            "UNIQUE(job_id_cups, server_id)",
+            "The id of the job must be unique per server !",
+        )
+    ]
+
+    def action_cancel(self):
+        self.ensure_one()
+        return self.cancel()
+
+    def cancel(self, purge_job=False):
+        for job in self:
+            connection = job.server_id._open_connection()
+            if not connection:
+                continue
+
+            connection.cancelJob(job.job_id_cups, purge_job=purge_job)
+
+        # Update jobs' states info Odoo
+        self.mapped("server_id").update_jobs(which="all", first_job_id=job.job_id_cups)
+
+        return True

odoo/addons/base_report_to_printer/models/printing_printer.py

@@ -0,0 +1,268 @@
+# Copyright (c) 2007 Ferran Pegueroles <ferran@pegueroles.com>
+# Copyright (c) 2009 Albert Cervera i Areny <albert@nan-tic.com>
+# Copyright (C) 2011 Agile Business Group sagl (<http://www.agilebg.com>)
+# Copyright (C) 2011 Domsense srl (<http://www.domsense.com>)
+# Copyright (C) 2013-2014 Camptocamp (<http://www.camptocamp.com>)
+# Copyright (C) 2016 SYLEAM (<http://www.syleam.fr>)
+# Copyright (C) 2023 Jacques-Etienne Baudoux (BCIM) <je@bcim.be>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+import errno
+import logging
+import os
+from tempfile import mkstemp
+
+from odoo import api, fields, models
+
+_logger = logging.getLogger(__name__)
+
+try:
+    import cups
+except ImportError:
+    _logger.debug("Cannot `import cups`.")
+
+
+class PrintingPrinter(models.Model):
+    """
+    Printers
+    """
+
+    _name = "printing.printer"
+    _description = "Printer"
+    _order = "name"
+
+    name = fields.Char(required=True, index=True)
+    active = fields.Boolean(default=True)
+    server_id = fields.Many2one(
+        comodel_name="printing.server",
+        string="Server",
+        required=True,
+        help="Server used to access this printer.",
+    )
+    job_ids = fields.One2many(
+        comodel_name="printing.job",
+        inverse_name="printer_id",
+        string="Jobs",
+        help="Jobs printed on this printer.",
+    )
+    system_name = fields.Char(required=True, index=True)
+    default = fields.Boolean(readonly=True)
+    status = fields.Selection(
+        selection=[
+            ("unavailable", "Unavailable"),
+            ("printing", "Printing"),
+            ("unknown", "Unknown"),
+            ("available", "Available"),
+            ("error", "Error"),
+            ("server-error", "Server Error"),
+        ],
+        required=True,
+        readonly=True,
+        default="unknown",
+    )
+    status_message = fields.Char(readonly=True)
+    model = fields.Char(readonly=True)
+    location = fields.Char(readonly=True)
+    uri = fields.Char(string="URI", readonly=True)
+    tray_ids = fields.One2many(
+        comodel_name="printing.tray", inverse_name="printer_id", string="Paper Sources"
+    )
+    multi_thread = fields.Boolean(
+        compute="_compute_multi_thread", readonly=False, store=True
+    )
+
+    @api.depends("server_id.multi_thread")
+    def _compute_multi_thread(self):
+        for printer in self:
+            printer.multi_thread = printer.server_id.multi_thread
+
+    def _prepare_update_from_cups(self, cups_connection, cups_printer):
+        mapping = {3: "available", 4: "printing", 5: "error"}
+        cups_vals = {
+            "name": self.name or cups_printer["printer-info"],
+            "model": cups_printer.get("printer-make-and-model", False),
+            "location": cups_printer.get("printer-location", False),
+            "uri": cups_printer.get("device-uri", False),
+            "status": mapping.get(cups_printer.get("printer-state"), "unknown"),
+            "status_message": cups_printer.get("printer-state-message", ""),
+        }
+
+        # prevent write if the field didn't change
+        vals = {
+            fieldname: value
+            for fieldname, value in cups_vals.items()
+            if not self or value != self[fieldname]
+        }
+
+        printer_uri = cups_printer["printer-uri-supported"]
+        printer_system_name = printer_uri[printer_uri.rfind("/") + 1 :]
+        ppd_info = cups_connection.getPPD3(printer_system_name)
+        ppd_path = ppd_info[2]
+        if not ppd_path:
+            return vals
+
+        ppd = cups.PPD(ppd_path)
+        option = ppd.findOption("InputSlot")
+        try:
+            os.unlink(ppd_path)
+        except OSError as err:
+            # ENOENT means No such file or directory
+            # The file has already been deleted, we can continue the update
+            if err.errno != errno.ENOENT:
+                raise
+        if not option:
+            return vals
+
+        tray_commands = []
+        cups_trays = {
+            tray_option["choice"]: tray_option["text"] for tray_option in option.choices
+        }
+
+        # Add new trays
+        tray_commands.extend(
+            [
+                (0, 0, {"name": text, "system_name": choice})
+                for choice, text in cups_trays.items()
+                if choice not in self.tray_ids.mapped("system_name")
+            ]
+        )
+
+        # Remove deleted trays
+        tray_commands.extend(
+            [
+                (2, tray.id)
+                for tray in self.tray_ids.filtered(
+                    lambda record: record.system_name not in cups_trays.keys()
+                )
+            ]
+        )
+        if tray_commands:
+            vals["tray_ids"] = tray_commands
+        return vals
+
+    def print_document(self, report, content, **print_opts):
+        """Print a file
+        Format could be pdf, qweb-pdf, raw, ...
+        """
+        self.ensure_one()
+        fd, file_name = mkstemp()
+        if isinstance(content, str):
+            content = content.encode()
+        try:
+            os.write(fd, content)
+        finally:
+            os.close(fd)
+
+        return self.print_file(file_name, report=report, **print_opts)
+
+    @staticmethod
+    def _set_option_doc_format(report, value):
+        return {"raw": "True"} if value == "raw" else {}
+
+    # Backwards compatibility of builtin used as kwarg
+    _set_option_format = _set_option_doc_format
+
+    def _set_option_tray(self, report, value):
+        """Note we use self here as some older PPD use tray
+        rather than InputSlot so we may need to query printer in override"""
+        return {"InputSlot": str(value)} if value else {}
+
+    @staticmethod
+    def _set_option_noop(report, value):
+        return {}
+
+    _set_option_action = _set_option_noop
+    _set_option_printer = _set_option_noop
+
+    def print_options(self, report=None, **print_opts):
+        options = {}
+        for option, value in print_opts.items():
+            try:
+                options.update(getattr(self, f"_set_option_{option}")(report, value))
+            except AttributeError:
+                options[option] = str(value)
+        return options
+
+    def print_file(self, file_name, report=None, **print_opts):
+        """Print a file"""
+        self.ensure_one()
+        title = print_opts.pop("title", file_name)
+        connection = self.server_id._open_connection(raise_on_error=True)
+        options = self.print_options(report=report, **print_opts)
+
+        _logger.debug(
+            f"Sending job to CUPS printer {self.system_name} on "
+            f"{self.server_id.address} with options {options}"
+        )
+        connection.printFile(self.system_name, file_name, title, options=options)
+        _logger.info(f"Printing job: '{file_name}' on {self.server_id.address}")
+        try:
+            os.remove(file_name)
+        except OSError as exc:
+            _logger.warning(f"Unable to remove temporary file {file_name}: {exc}")
+        return True
+
+    def set_default(self):
+        if not self:
+            return
+        self.ensure_one()
+        default_printers = self.search([("default", "=", True)])
+        default_printers.unset_default()
+        self.write({"default": True})
+        return True
+
+    def unset_default(self):
+        self.write({"default": False})
+        return True
+
+    def get_default(self):
+        return self.search([("default", "=", True)], limit=1)
+
+    def action_cancel_all_jobs(self):
+        self.ensure_one()
+        return self.cancel_all_jobs()
+
+    def cancel_all_jobs(self, purge_jobs=False):
+        for printer in self:
+            connection = printer.server_id._open_connection()
+            connection.cancelAllJobs(name=printer.system_name, purge_jobs=purge_jobs)
+
+        # Update jobs' states into Odoo
+        self.mapped("server_id").update_jobs(which="completed")
+
+        return True
+
+    def enable(self):
+        for printer in self:
+            connection = printer.server_id._open_connection()
+            connection.enablePrinter(printer.system_name)
+
+        # Update printers' stats into Odoo
+        self.mapped("server_id").update_printers()
+
+        return True
+
+    def disable(self):
+        for printer in self:
+            connection = printer.server_id._open_connection()
+            connection.disablePrinter(printer.system_name)
+
+        # Update printers' stats into Odoo
+        self.mapped("server_id").update_printers()
+
+        return True
+
+    def print_test_page(self):
+        for printer in self:
+            connection = printer.server_id._open_connection()
+            if printer.model == "Local Raw Printer":
+                fd, file_name = mkstemp()
+                try:
+                    os.write(fd, b"TEST")
+                finally:
+                    os.close(fd)
+                connection.printTestPage(printer.system_name, file=file_name)
+            else:
+                connection.printTestPage(printer.system_name)
+
+        self.mapped("server_id").update_jobs(which="completed")