odoo-addon-l10n-es-verifactu-oca 16.0.1.0.0.22__py3-none-any.whl

odoo/addons/l10n_es_verifactu_oca/models/aeat_tax_agency.py

@@ -0,0 +1,30 @@
+# Copyright 2024 Aures Tic - Jose Zambudio <jose@aurestic.es>
+# Copyright 2024 Aures TIC - Almudena de La Puente <almudena@aurestic.es>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class AeatTaxAgency(models.Model):
+    _inherit = "aeat.tax.agency"
+
+    verifactu_wsdl_out = fields.Char(string="VERI*FACTU WSDL")
+    verifactu_wsdl_out_test_address = fields.Char(string="VERI*FACTU Test Address")
+    verifactu_qr_base_url = fields.Char(string="VERI*FACTU QR Base URL")
+    verifactu_qr_base_url_test_address = fields.Char(
+        string="VERI*FACTU QR Base URL Test"
+    )
+
+    def _connect_params_verifactu(self, company):
+        self.ensure_one()
+        wsdl_field = "verifactu_wsdl_out"
+        wsdl_test_field = wsdl_field + "_test_address"
+        port_name = "SistemaVerifactu"
+        address = self[wsdl_test_field] if company.verifactu_test else False
+        if not address and company.verifactu_test:
+            port_name += "Pruebas"
+        return {
+            "wsdl": self[wsdl_field],
+            "address": address,
+            "port_name": port_name,
+        }

odoo/addons/l10n_es_verifactu_oca/models/res_company.py

@@ -0,0 +1,48 @@
+# Copyright 2024 Aures TIC - Jose Zambudio
+# Copyright 2025 Tecnativa - Pedro M. Baeza
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class ResCompany(models.Model):
+    _inherit = "res.company"
+
+    verifactu_enabled = fields.Boolean(string="VERI*FACTU enabled", tracking=True)
+    verifactu_test = fields.Boolean(
+        string="VERI*FACTU test environment?", tracking=True
+    )
+    verifactu_description = fields.Text(
+        string="VERI*FACTU description",
+        default="/",
+        help="The description for VERI*FACTU invoices if not set",
+        tracking=True,
+    )
+    verifactu_developer_id = fields.Many2one(
+        comodel_name="verifactu.developer",
+        string="VERI*FACTU developer",
+        ondelete="restrict",
+        tracking=True,
+    )
+    verifactu_start_date = fields.Date(
+        string="VERI*FACTU start date",
+        help="If this field is set, the VERI*FACTU won't be enabled on invoices with "
+        "lower invoice date. If not set, it can be enabled on all invoice dates",
+        tracking=True,
+    )
+    verifactu_chaining_id = fields.Many2one(
+        comodel_name="verifactu.chaining",
+        string="VERI*FACTU chaining",
+        ondelete="restrict",
+        tracking=True,
+    )
+
+    def write(self, vals):
+        # As the compute is not triggered automatically, we need to manually trigger it
+        # rewriting the flag at journal level.
+        res = super().write(vals)
+        if vals.get("verifactu_enabled"):
+            self.env["account.journal"].search(
+                [("company_id", "in", self.ids), ("type", "=", "sale")]
+            ).verifactu_enabled = True
+        return res

odoo/addons/l10n_es_verifactu_oca/models/res_partner.py

@@ -0,0 +1,26 @@
+# Copyright 2024 Aures TIC - Jose Zambudio
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo import api, fields, models
+
+
+class ResPartner(models.Model):
+    _inherit = "res.partner"
+
+    verifactu_enabled = fields.Boolean(
+        compute="_compute_aeat_sending_enabled", string="VERI*FACTU enabled"
+    )
+
+    @api.depends("company_id")
+    def _compute_aeat_sending_enabled(self):
+        res = super()._compute_aeat_sending_enabled()
+        verifactu_enabled = any(self.env.companies.mapped("verifactu_enabled"))
+        for partner in self:
+            partner.verifactu_enabled = (
+                partner.company_id.verifactu_enabled
+                if partner.company_id
+                else verifactu_enabled
+            )
+            if partner.verifactu_enabled:
+                partner.aeat_sending_enabled = True
+        return res

odoo/addons/l10n_es_verifactu_oca/models/verifactu_chaining.py

@@ -0,0 +1,30 @@
+# Copyright 2024 Aures TIC - Almudena de La Puente <almudena@aurestic.es>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class VerifactuChaining(models.Model):
+    _name = "verifactu.chaining"
+    _inherit = "mail.thread"
+    _description = "VERI*FACTU chaining"
+
+    name = fields.Char(required=True, tracking=True)
+    last_verifactu_invoice_entry_id = fields.Many2one(
+        comodel_name="verifactu.invoice.entry",
+        string="Last invoice entry",
+        help="Reference to the last VERI*FACTU invoice entry for this company. "
+        "Used for atomic chaining.",
+        copy=False,
+        readonly=True,
+    )
+    sif_id = fields.Char(string="SIF ID", required=True, tracking=True)
+    installation_number = fields.Integer(default=1, required=True, tracking=True)
+
+    _sql_constraints = [
+        (
+            "verifactu_chaining_name_uniq",
+            "unique(name)",
+            "A chaining with the same name already exists!",
+        )
+    ]

odoo/addons/l10n_es_verifactu_oca/models/verifactu_developer.py

@@ -0,0 +1,16 @@
+# Copyright 2024 Aures TIC - Almudena de La Puente
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class VerifactuDeveloper(models.Model):
+    _name = "verifactu.developer"
+    _description = "VERI*FACTU developer"
+    _inherit = "mail.thread"
+
+    name = fields.Char(string="Developer Name", required=True, tracking=True)
+    vat = fields.Char(string="Developer VAT", required=True, tracking=True)
+    sif_name = fields.Char("SIF Name", required=True, tracking=True)
+    version = fields.Char(default="1.0", required=True, tracking=True)
+    responsibility_declaration = fields.Binary(attachment=True, copy=False)

odoo/addons/l10n_es_verifactu_oca/models/verifactu_invoice_entry.py

@@ -0,0 +1,378 @@
+# Copyright 2025 ForgeFlow S.L.
+# Copyright 2025 Tecnativa - Pedro M. Baeza
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+import datetime
+import json
+
+from requests import Session
+from zeep import Client, Settings
+from zeep.plugins import HistoryPlugin
+from zeep.transports import Transport
+
+from odoo import _, api, fields, models
+from odoo.exceptions import UserError
+from odoo.tools import split_every
+
+VERIFACTU_SEND_STATES = [
+    ("not_sent", "Not sent"),
+    ("correct", "Sent and Correct"),
+    ("incorrect", "Sent and Incorrect"),
+    ("accepted_with_errors", "Sent and accepted with errors"),
+]
+
+VERIFACTU_STATE_MAPPING = {
+    "Correcto": "correct",
+    "Incorrecto": "incorrect",
+    "AceptadoConErrores": "accepted_with_errors",
+}
+
+
+class VerifactuInvoiceEntry(models.Model):
+    _name = "verifactu.invoice.entry"
+    _description = "VERI*FACTU invoice entry"
+    _order = "id desc"
+    _rec_name = "document_hash"
+
+    verifactu_chaining_id = fields.Many2one(
+        "verifactu.chaining", string="Chaining", ondelete="restrict", required=True
+    )
+    model = fields.Char(readonly=True, required=True)
+    document_id = fields.Many2oneReference(
+        string="Document", model_field="model", readonly=True, index=True, required=True
+    )
+    document_name = fields.Char(readonly=True)
+    previous_invoice_entry_id = fields.Many2one(
+        "verifactu.invoice.entry", string="Previous Invoice Entry", readonly=True
+    )
+    company_id = fields.Many2one(
+        "res.company", string="Company", required=True, readonly=True
+    )
+    document_hash = fields.Char(required=True, readonly=True)
+    aeat_json_data = fields.Text(
+        string="AEAT JSON Data",
+        help="Generated JSON data to send to AEAT",
+        readonly=True,
+    )
+    send_state = fields.Selection(
+        selection=VERIFACTU_SEND_STATES,
+        compute="_compute_send_state",
+        default="not_sent",
+        readonly=True,
+        store=True,
+        copy=False,
+        help="Indicates the state of this document in relation with the "
+        "presentation to VERI*FACTU.",
+    )
+    send_attempt = fields.Integer(
+        default=0, help="Number of attempts to send this document."
+    )
+    response_line_ids = fields.One2many(
+        "verifactu.invoice.entry.response.line",
+        "entry_id",
+        string="Responses",
+        help="Responses from VERI*FACTU after sending the documents.",
+    )
+    last_error_code = fields.Char(compute="_compute_last_error_code", store=True)
+    previous_hash = fields.Char(
+        related="previous_invoice_entry_id.document_hash",
+        readonly=True,
+        string="Previous Hash",
+    )
+    entry_type = fields.Selection(
+        selection=[
+            ("register", "Register"),
+            ("modify", "Modify"),
+            ("cancel", "Cancel"),
+        ],
+        default="register",
+        required=True,
+    )
+    last_response_line_id = fields.Many2one(
+        "verifactu.invoice.entry.response.line",
+        string="Last Response Line",
+        readonly=True,
+    )
+
+    @api.depends("response_line_ids", "response_line_ids.send_state")
+    def _compute_send_state(self):
+        for rec in self:
+            rec.send_state = "not_sent"
+            last_response = rec.last_response_line_id
+            if last_response:
+                rec.send_state = last_response.send_state
+
+    @api.depends("response_line_ids", "response_line_ids.error_code")
+    def _compute_last_error_code(self):
+        """Compute the last error code from the response lines."""
+        for rec in self:
+            if rec.last_response_line_id:
+                rec.last_error_code = rec.last_response_line_id.error_code
+            else:
+                rec.last_error_code = ""
+
+    @property
+    def document(self):
+        return self.env[self.model].browse(self.document_id).exists()
+
+    @api.model
+    def _cron_send_documents_to_verifactu(self):
+        batch_limit = self.env["verifactu.mixin"]._get_verifactu_batch()
+        for chaining in self.env["verifactu.chaining"].search([]):
+            self.env.cr.execute(
+                """
+                SELECT id FROM verifactu_invoice_entry AS vsq
+                WHERE vsq.send_state in ('not_sent', 'incorrect')
+                AND vsq.verifactu_chaining_id = %s
+                ORDER BY id
+                FOR UPDATE NOWAIT
+                """,
+                [chaining.id],
+            )
+            entries_to_send_ids = [entry[0] for entry in self.env.cr.fetchall()]
+            for entries_batch_ids in split_every(batch_limit, entries_to_send_ids):
+                records_to_send = self.browse(entries_batch_ids)
+                send_date = fields.Datetime.now()
+                threshold_time = send_date - datetime.timedelta(seconds=240)
+                # Look for documents where we have to send as an incident
+                outdated_records = records_to_send.filtered(
+                    lambda r: r.document.verifactu_registration_date < threshold_time
+                )
+                current_records = records_to_send - outdated_records
+                outdated_records.with_context(
+                    verifactu_incident=True
+                )._send_documents_to_verifactu()
+                current_records._send_documents_to_verifactu()
+        return True
+
+    def _get_verifactu_aeat_header(self):
+        """Builds VERI*FACTU send header
+
+        :param tipo_comunicacion String 'A0': new reg, 'A1': modification
+        :param cancellation Bool True when the communitacion es for document
+            cancellation
+        :return Dict with header data depending on cancellation
+        """
+        self.ensure_one()
+        if not self.company_id.vat:
+            raise UserError(
+                _("No VAT configured for the company '{}'").format(self.company_id.name)
+            )
+        header = {
+            "ObligadoEmision": {
+                "NombreRazon": self.company_id.name[0:120],
+                "NIF": self.company_id.partner_id._parse_aeat_vat_info()[2],
+            },
+        }
+        incident = self.env.context.get("verifactu_incident", False)
+        if incident:
+            header.update({"RemisionVoluntaria": {"Incidencia": "S"}})
+        return header
+
+    def _bind_verifactu_service(self, client, port_name, address=None):
+        self.ensure_one()
+        service = client._get_service("sfVerifactu")
+        port = client._get_port(service, port_name)
+        address = address or port.binding_options["address"]
+        return client.create_service(port.binding.name, address)
+
+    def _connect_verifactu_params_aeat(self):
+        self.ensure_one()
+        agency = self.company_id.tax_agency_id
+        if not agency:
+            # We use spanish agency by default to keep old behavior with
+            # ir.config parameters. In the future it might be good to reinforce
+            # to explicitly set a tax agency in the company by raising an error
+            # here.
+            agency = self.env.ref("l10n_es_aeat.aeat_tax_agency_spain")
+        return agency._connect_params_verifactu(self.company_id)
+
+    def _connect_verifactu(self):
+        self.ensure_one()
+        public_crt, private_key = self.env["l10n.es.aeat.certificate"].get_certificates(
+            company=self.company_id
+        )
+        if not public_crt or not private_key:
+            raise UserError(
+                _("Please, configure the VERI*FACTU certificates for your company")
+            )
+        params = self._connect_verifactu_params_aeat()
+        session = Session()
+        session.cert = (public_crt, private_key)
+        transport = Transport(session=session)
+        history = HistoryPlugin()
+        settings = Settings(forbid_entities=False)
+        client = Client(
+            wsdl=params["wsdl"],
+            transport=transport,
+            plugins=[history],
+            settings=settings,
+        )
+        return self._bind_verifactu_service(
+            client, params["port_name"], params["address"]
+        )
+
+    def _process_response_line_doc_vals(
+        self,
+        verifactu_response=False,
+        verifactu_response_line=False,
+        response_line=False,
+        previous_response_line=False,
+        header_sent=False,
+    ):
+        estado_registro = verifactu_response_line["EstadoRegistro"]
+        doc_vals = {
+            "aeat_header_sent": json.dumps(header_sent, indent=4),
+        }
+        doc_vals["verifactu_return"] = verifactu_response_line
+        send_error = False
+        if hasattr(verifactu_response_line, "CodigoErrorRegistro"):
+            send_error = "{} | {}".format(
+                str(verifactu_response_line["CodigoErrorRegistro"]),
+                str(verifactu_response_line["DescripcionErrorRegistro"]),
+            )
+            # si ya ha devuelto previamente registro duplicado, parseamos el estado
+            # del registro duplicado para dejar la factura correcta o incorrecta
+            if (
+                verifactu_response_line["CodigoErrorRegistro"] == 3000
+                and previous_response_line
+                and (
+                    previous_response_line.error_code == "3000"
+                    and previous_response_line.send_state == "incorrect"
+                )
+            ):
+                registroDuplicado = verifactu_response_line["RegistroDuplicado"]
+                estado_registro = registroDuplicado["EstadoRegistroDuplicado"]
+                # en duplicados devuelve Correcta en vez de Correcto...
+                if estado_registro == "Correcta":
+                    estado_registro = "Correcto"
+                    response_line.send_state = "correct"
+                elif registroDuplicado["CodigoErrorRegistro"]:
+                    # en duplicados devuelve AceptadaConErrores en vez de AceptadoConErrores...
+                    if estado_registro == "AceptadaConErrores":
+                        estado_registro = "AceptadoConErrores"
+                        response_line.send_state = "accepted_with_errors"
+                    send_error = "{} | {}".format(
+                        str(registroDuplicado["CodigoErrorRegistro"]),
+                        str(registroDuplicado["DescripcionErrorRegistro"]),
+                    )
+        if estado_registro == "Correcto":
+            doc_vals.update(
+                {
+                    "aeat_state": "sent",
+                    "verifactu_csv": verifactu_response["CSV"],
+                    "aeat_send_failed": False,
+                }
+            )
+        elif estado_registro == "AceptadoConErrores":
+            doc_vals.update(
+                {
+                    "aeat_state": "sent_w_errors",
+                    "verifactu_csv": verifactu_response["CSV"],
+                    "aeat_send_failed": True,
+                }
+            )
+        else:
+            doc_vals["aeat_send_failed"] = True
+        doc_vals["aeat_send_error"] = send_error
+        if response_line.document_id:
+            response_line.document.write(doc_vals)
+        return doc_vals
+
+    def _send_documents_to_verifactu(self):
+        if not self:
+            return False
+        rec = self[0]
+        header = rec._get_verifactu_aeat_header()
+        registro_factura_list = []
+        create_exception = False
+        for rec in self:
+            rec.send_attempt += 1
+            if rec.document:
+                inv_dict = rec.document._get_verifactu_invoice_dict()
+                registro_factura_list.append(inv_dict)
+        try:
+            serv = rec._connect_verifactu()
+            res = serv.RegFactuSistemaFacturacion(header, registro_factura_list)
+        except Exception:
+            res = {}
+            create_exception = True
+        response_name = ""
+        response = (
+            self.env["verifactu.invoice.entry.response"]
+            .sudo()
+            .create(
+                {
+                    "header": json.dumps(header),
+                    "name": response_name,
+                    "invoice_data": json.dumps(registro_factura_list),
+                    "response": res,
+                    "verifactu_csv": "CSV" in res and res["CSV"] or _("-"),
+                }
+            )
+        )
+        response.complete_open_activity_on_exception()
+        if create_exception:
+            if not response.date_response:
+                response.date_response = fields.Datetime.now()
+            response.create_activity_on_exception()
+        create_response_activity = self._create_response_lines(
+            response=response, header=header, verifactu_response=res
+        )
+        updated_response_name = _("VERI*FACTU sending")
+        if create_exception:
+            updated_response_name = _("Connection error with VERI*FACTU")
+        elif create_response_activity:
+            updated_response_name = _("Incorrect invoices sent to VERI*FACTU")
+        response.name = updated_response_name
+        if create_response_activity:
+            response.create_send_response_activity()
+        return True
+
+    def _create_response_lines(
+        self, response=False, header=False, verifactu_response=False
+    ):
+        create_response_activity = False
+        respuestaLineas = verifactu_response.get("RespuestaLinea", [])
+        for verifactu_response_line in respuestaLineas:
+            invoice_num = verifactu_response_line["IDFactura"]["NumSerieFactura"]
+            for model in self.env["verifactu.mixin"]._get_verifactu_reference_models():
+                if document := self.env[model].search(
+                    [
+                        ("name", "=", invoice_num),
+                        ("id", "in", self.mapped("document_id")),
+                    ],
+                    limit=1,
+                ):
+                    break
+            # Find the verifactu.invoice entry for this document
+            verifactu_invoice_entry = document.last_verifactu_invoice_entry_id
+            previous_response_line = document.last_verifactu_response_line_id
+            send_state = VERIFACTU_STATE_MAPPING[
+                verifactu_response_line["EstadoRegistro"]
+            ]
+            vals = {
+                "entry_id": verifactu_invoice_entry.id,
+                "model": verifactu_invoice_entry.model,
+                "document_id": verifactu_invoice_entry.document_id,
+                "response": verifactu_response_line,
+                "entry_response_id": response.id,
+                "send_state": send_state,
+                "error_code": "CodigoErrorRegistro" in verifactu_response_line
+                and str(verifactu_response_line["CodigoErrorRegistro"])
+                or "",
+            }
+            response_line = (
+                self.env["verifactu.invoice.entry.response.line"].sudo().create(vals)
+            )
+            document.last_verifactu_response_line_id = response_line
+            verifactu_invoice_entry.last_response_line_id = response_line
+            self._process_response_line_doc_vals(
+                verifactu_response=verifactu_response,
+                verifactu_response_line=verifactu_response_line,
+                response_line=response_line,
+                previous_response_line=previous_response_line,
+                header_sent=header,
+            )
+            if send_state != "correct":
+                create_response_activity = True
+        return create_response_activity

odoo/addons/l10n_es_verifactu_oca/models/verifactu_invoice_entry_response.py

@@ -0,0 +1,122 @@
+# Copyright 2025 ForgeFlow S.L.
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import _, fields, models
+
+VERIFACTU_STATE_MAPPING = {
+    "Correcto": "correct",
+    "Incorrecto": "incorrect",
+    "AceptadoConErrores": "accepted_with_errors",
+}
+
+
+class VerifactuInvoiceEntryResponse(models.Model):
+    _name = "verifactu.invoice.entry.response"
+    _description = "VERI*FACTU Send Response"
+    _inherit = ["mail.activity.mixin", "mail.thread"]
+    _order = "id desc"
+
+    header = fields.Text()
+    name = fields.Char()
+    invoice_data = fields.Text()
+    response = fields.Text()
+    verifactu_csv = fields.Text(string="VERI*FACTU CSV")
+    date_response = fields.Datetime(readonly=True)
+    activity_type_id = fields.Many2one(
+        "mail.activity.type",
+        string="Activity Type",
+        compute="_compute_activity_type_id",
+        store=True,
+    )
+    response_line_ids = fields.One2many(
+        "verifactu.invoice.entry.response.line",
+        "entry_response_id",
+        string="Response lines",
+    )
+
+    def _compute_activity_type_id(self):
+        for record in self:
+            activity = self.env["mail.activity"].search(
+                [
+                    ("res_model", "=", "verifactu.invoice.entry.response"),
+                    ("res_id", "=", record.id),
+                ],
+                limit=1,
+            )
+            record.activity_type_id = activity.activity_type_id if activity else False
+
+    def create_activity_on_exception(self):
+        model_id = self.env["ir.model"]._get_id("verifactu.invoice.entry.response")
+        exception_activity_type = self.env.ref(
+            "l10n_es_verifactu_oca.mail_activity_data_exception"
+        )
+        activity_vals = []
+        responsible_group = self.env.ref(
+            "l10n_es_verifactu_oca.group_verifactu_responsible"
+        )
+        users = responsible_group.users
+        for record in self:
+            existing = self.env["mail.activity"].search_count(
+                [
+                    ("activity_type_id", "=", exception_activity_type.id),
+                    ("res_model", "=", "verifactu.invoice.entry.response"),
+                ],
+                limit=1,
+            )
+            if not existing:
+                user = users[:1] or self.env.user
+                activity_vals.append(
+                    {
+                        "res_model_id": model_id,
+                        "res_model": "verifactu.invoice.entry.response",
+                        "res_id": record.id,
+                        "activity_type_id": exception_activity_type.id,
+                        "user_id": user.id,
+                        "summary": _("Check connection error with VERI*FACTU"),
+                        "note": _(
+                            "There has been an error when trying to connect to "
+                            "VERI*FACTU"
+                        ),
+                    }
+                )
+        if activity_vals:
+            return self.env["mail.activity"].create(activity_vals)
+        return False
+
+    def create_send_response_activity(self):
+        activity_type = self.env.ref("mail.mail_activity_data_warning")
+        model_id = self.env["ir.model"]._get_id("verifactu.invoice.entry.response")
+        activity_vals = []
+        responsible_group = self.env.ref(
+            "l10n_es_verifactu_oca.group_verifactu_responsible"
+        )
+        users = responsible_group.users
+        for record in self:
+            user = users[:1] or self.env.user
+            activity_vals.append(
+                {
+                    "activity_type_id": activity_type.id,
+                    "user_id": user.id,
+                    "res_id": record.id,
+                    "res_model": "verifactu.invoice.entry.response",
+                    "res_model_id": model_id,
+                    "summary": _("Check incorrect invoices from VERI*FACTU"),
+                    "note": _("There is an error with one or more invoices"),
+                }
+            )
+        return self.env["mail.activity"].create(activity_vals)
+
+    def complete_open_activity_on_exception(self):
+        exception_activity_type = self.env.ref(
+            "l10n_es_verifactu_oca.mail_activity_data_exception"
+        )
+        for _record in self:
+            activity = self.env["mail.activity"].search(
+                [
+                    ("activity_type_id", "=", exception_activity_type.id),
+                    ("res_model", "=", "verifactu.invoice.entry.response"),
+                ],
+            )
+        for act in activity:
+            if act.state != "done":
+                act.action_done()
+        return True