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

odoo/addons/l10n_es_verifactu_oca/models/verifactu_invoice_entry.py

@@ -0,0 +1,401 @@
+# 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
+import logging
+
+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
+
+_logger = logging.getLogger(__name__)
+
+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 as e:
+            _logger.error("Error sending documents to VERI*FACTU: %s", e)
+            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
+        # the returned object doesn't have `get` method, so use this form
+        verifactu_response_lines = (
+            "RespuestaLinea" in verifactu_response
+            and verifactu_response["RespuestaLinea"]
+            or []
+        )
+        models = self.env["verifactu.mixin"]._get_verifactu_reference_models()
+        for verifactu_response_line in verifactu_response_lines:
+            invoice_num = verifactu_response_line["IDFactura"]["NumSerieFactura"]
+            document = False
+            for model in models:
+                document = self.env[model].search(
+                    [
+                        ("name", "=", invoice_num),
+                        ("id", "in", self.mapped("document_id")),
+                    ],
+                    limit=1,
+                )
+                if document:
+                    break
+
+            # Skip if document not found
+            if not document:
+                continue
+
+            # Find the verifactu.invoice entry for this document
+            verifactu_invoice_entry = document.last_verifactu_invoice_entry_id
+
+            # Skip if no verifactu invoice entry found - this should not happen
+            # in normal flow but can happen in tests with mocked responses
+            if not verifactu_invoice_entry:
+                continue
+
+            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,121 @@
+# 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"),
+                ]
+            )
+            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

odoo/addons/l10n_es_verifactu_oca/models/verifactu_invoice_entry_response_line.py

@@ -0,0 +1,35 @@
+# Copyright 2025 ForgeFlow S.L.
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo import fields, models
+
+from ..models.verifactu_invoice_entry import VERIFACTU_SEND_STATES
+
+
+class VerifactuInvoiceEntryResponseLine(models.Model):
+    _name = "verifactu.invoice.entry.response.line"
+    _description = "VERI*FACTU send log"
+    _order = "id desc"
+
+    entry_id = fields.Many2one(comodel_name="verifactu.invoice.entry", required=True)
+    entry_response_id = fields.Many2one("verifactu.invoice.entry.response")
+    model = fields.Char(readonly=True)
+    document_id = fields.Many2oneReference(
+        string="Document", model_field="model", readonly=True, index=True
+    )
+    response = fields.Text()
+    send_state = fields.Selection(
+        selection=VERIFACTU_SEND_STATES,
+        string="VERI*FACTU send state",
+        default="not_sent",
+        readonly=True,
+        copy=False,
+        help="Indicates the state of this document in relation with the "
+        "presentation to VERI*FACTU.",
+    )
+    verifactu_csv = fields.Text(related="entry_response_id.verifactu_csv")
+    error_code = fields.Char()
+
+    @property
+    def document(self):
+        return self.env[self.model].browse(self.document_id).exists()

odoo/addons/l10n_es_verifactu_oca/models/verifactu_map.py

@@ -0,0 +1,66 @@
+# Copyright 2024 Aures TIC - Almudena de La Puente <almudena@aurestic.es>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo import _, api, exceptions, fields, models
+
+
+class AeatVerifactuMap(models.Model):
+    _name = "verifactu.map"
+    _description = "VERI*FACTU mapping"
+
+    name = fields.Char(string="Model", required=True)
+    date_from = fields.Date()
+    date_to = fields.Date()
+    map_lines = fields.One2many(
+        comodel_name="verifactu.map.line",
+        inverse_name="verifactu_map_id",
+        string="Lines",
+    )
+
+    @api.constrains("date_from", "date_to")
+    def _unique_date_range(self):
+        for record in self:
+            record._unique_date_range_one()
+
+    def _unique_date_range_one(self):
+        # Based in l10n_es_aeat module
+        domain = [("id", "!=", self.id)]
+        if self.date_from and self.date_to:
+            domain += [
+                "|",
+                "&",
+                ("date_from", "<=", self.date_to),
+                ("date_from", ">=", self.date_from),
+                "|",
+                "&",
+                ("date_to", "<=", self.date_to),
+                ("date_to", ">=", self.date_from),
+                "|",
+                "&",
+                ("date_from", "=", False),
+                ("date_to", ">=", self.date_from),
+                "|",
+                "&",
+                ("date_to", "=", False),
+                ("date_from", "<=", self.date_to),
+            ]
+        elif self.date_from:
+            domain += [("date_to", ">=", self.date_from)]
+        elif self.date_to:
+            domain += [("date_from", "<=", self.date_to)]
+        date_lst = self.search(domain)
+        if date_lst:
+            raise exceptions.UserError(
+                _("Error! The dates of the record overlap with an existing " "record.")
+            )
+
+
+class AeatVerifactuMapLines(models.Model):
+    _name = "verifactu.map.line"
+    _description = "VERI*FACTU mapping line"
+
+    code = fields.Char(required=True)
+    name = fields.Char()
+    taxes = fields.Many2many(comodel_name="account.tax.template")
+    verifactu_map_id = fields.Many2one(
+        comodel_name="verifactu.map", string="Parent mapping", ondelete="cascade"
+    )