odoo-addon-l10n-es-aeat-sii-oca 16.0.1.3.2.1__py3-none-any.whl → 16.0.1.5.0.1__py3-none-any.whl

odoo/addons/l10n_es_aeat_sii_oca/models/account_move.py

@@ -7,25 +7,19 @@
 # Copyright 2021 Tecnativa - João Marques
 # Copyright 2022 ForgeFlow - Lois Rilo
 # Copyright 2011-2023 Tecnativa - Pedro M. Baeza
+# Copyright 2023 Aures Tic - Almudena de la Puente <almudena@aurestic.es>
+# Copyright 2023 Aures Tic - Jose Zambudio <jose@aurestic.es>
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
 
 import json
 import logging
 
-from requests import Session
-
 from odoo import _, api, exceptions, fields, models
 from odoo.modules.registry import Registry
-from odoo.tools.float_utils import float_compare
 
+SII_VALID_INVOICE_STATES = ["posted"]
 _logger = logging.getLogger(__name__)
 
-try:
-    from zeep import Client
-    from zeep.plugins import HistoryPlugin
-    from zeep.transports import Transport
-except (ImportError, IOError) as err:
-    _logger.debug(err)
 
 try:
     from odoo.addons.queue_job.job import job
@@ -38,84 +32,19 @@ except ImportError:
 
     job = empty_decorator_factory
 
-SII_STATES = [
-    ("not_sent", "Not sent"),
-    ("sent", "Sent"),
-    ("sent_w_errors", "Accepted with errors"),
-    ("sent_modified", "Registered in SII but last modifications not sent"),
-    ("cancelled", "Cancelled"),
-    ("cancelled_modified", "Cancelled in SII but last modifications not sent"),
-]
-SII_VERSION = "1.1"
-SII_MACRODATA_LIMIT = 100000000.0
-SII_VALID_INVOICE_STATES = ["posted"]
-
 
-def round_by_keys(elem, search_keys, prec=2):
-    """This uses ``round`` method directly as if has been tested that Odoo's
-    ``float_round`` still returns incorrect amounts for certain values. Try
-    3 units x 3,77 €/unit with 10% tax and you will be hit by the error
-    (on regular x86 architectures)."""
-    if isinstance(elem, dict):
-        for key, value in elem.items():
-            if key in search_keys:
-                elem[key] = round(elem[key], prec)
-            else:
-                round_by_keys(value, search_keys)
-    elif isinstance(elem, list):
-        for value in elem:
-            round_by_keys(value, search_keys)
+class AccountMove(models.Model):
+    _name = "account.move"
+    _inherit = ["account.move", "sii.mixin"]
 
+    def _get_default_type(self):
+        context = self.env.context
+        return context.get("move_type", context.get("default_move_type"))
 
-class AccountMove(models.Model):
-    _inherit = "account.move"
+    def _default_sii_refund_type(self):
+        inv_type = self._get_default_type()
+        return "I" if inv_type in ["out_refund", "in_refund"] else False
 
-    sii_description = fields.Text(
-        string="SII computed description",
-        compute="_compute_sii_description",
-        default="/",
-        store=True,
-        readonly=False,
-        copy=False,
-    )
-    sii_state = fields.Selection(
-        selection=SII_STATES,
-        string="SII send state",
-        default="not_sent",
-        readonly=True,
-        copy=False,
-        help="Indicates the state of this invoice in relation with the "
-        "presentation at the SII",
-    )
-    sii_csv = fields.Char(string="SII CSV", copy=False, readonly=True)
-    sii_return = fields.Text(string="SII Return", copy=False, readonly=True)
-    sii_header_sent = fields.Text(
-        string="SII last header sent",
-        copy=False,
-        readonly=True,
-    )
-    sii_content_sent = fields.Text(
-        string="SII last content sent",
-        copy=False,
-        readonly=True,
-    )
-    sii_send_error = fields.Text(string="SII Send Error", readonly=True, copy=False)
-    sii_send_failed = fields.Boolean(
-        string="SII send failed",
-        copy=False,
-        help="Indicates that the last attempt to communicate this invoice to "
-        "the SII has failed. See SII return for details",
-    )
-    sii_refund_type = fields.Selection(
-        selection=[
-            # ('S', 'By substitution'), - Removed as not fully supported
-            ("I", "By differences"),
-        ],
-        string="SII Refund Type",
-        compute="_compute_sii_refund_type",
-        store=True,
-        readonly=False,
-    )
     sii_refund_specific_invoice_type = fields.Selection(
         selection=[
             ("R1", "Error based on law and Art. 80 One and Two LIVA (R1)"),
@@ -127,28 +56,6 @@ class AccountMove(models.Model):
         " of article 80 of LIVA for notifying to SII with the proper"
         " invoice type.",
     )
-    sii_account_registration_date = fields.Date(
-        string="SII account registration date",
-        readonly=True,
-        copy=False,
-        help="Indicates the account registration date set at the SII, which "
-        "must be the date when the invoice is recorded in the system and "
-        "is independent of the date of the accounting entry of the "
-        "invoice",
-    )
-    sii_registration_key_domain = fields.Char(
-        compute="_compute_sii_registration_key_domain",
-        string="SII registration key domain",
-    )
-    sii_registration_key = fields.Many2one(
-        comodel_name="aeat.sii.mapping.registration.keys",
-        string="SII registration key",
-        compute="_compute_sii_registration_key",
-        store=True,
-        readonly=False,
-        # required=True, This is not set as required here to avoid the
-        # set not null constraint warning
-    )
     sii_registration_key_additional1 = fields.Many2one(
         comodel_name="aeat.sii.mapping.registration.keys",
         string="Additional SII registration key",
@@ -157,12 +64,6 @@ class AccountMove(models.Model):
         comodel_name="aeat.sii.mapping.registration.keys",
         string="Additional 2 SII registration key",
     )
-    sii_registration_key_code = fields.Char(
-        related="sii_registration_key.code",
-        readonly=True,
-        string="SII Code",
-    )
-    sii_enabled = fields.Boolean(string="Enable SII", compute="_compute_sii_enabled")
     sii_property_location = fields.Selection(
         string="Real property location",
         copy=False,
@@ -185,12 +86,6 @@ class AccountMove(models.Model):
         string="Real property cadastrial code",
         copy=False,
     )
-    sii_macrodata = fields.Boolean(
-        string="MacroData",
-        help="Check to confirm that the invoice has an absolute amount "
-        "greater o equal to 100 000 000,00 euros.",
-        compute="_compute_macrodata",
-    )
     sii_lc_operation = fields.Boolean(
         string="Customs - Complementary settlement",
         help="Check this mark if this invoice represents a complementary "
@@ -209,51 +104,23 @@ class AccountMove(models.Model):
 
     @api.depends("move_type")
     def _compute_sii_refund_type(self):
-        self.sii_refund_type = False
         for record in self:
             if "refund" in (record.move_type or ""):
                 record.sii_refund_type = "I"
+            else:
+                record.sii_refund_type = False
 
     @api.depends("move_type")
     def _compute_sii_registration_key_domain(self):
-        for record in self:
-            if record.move_type in {"out_invoice", "out_refund"}:
-                record.sii_registration_key_domain = "sale"
-            elif record.move_type in {"in_invoice", "in_refund"}:
-                record.sii_registration_key_domain = "purchase"
-            else:
-                record.sii_registration_key_domain = False
+        return super()._compute_sii_registration_key_domain()
 
-    @api.depends("fiscal_position_id", "move_type")
+    @api.depends("move_type")
     def _compute_sii_registration_key(self):
-        for invoice in self:
-            if invoice.fiscal_position_id:
-                if "out" in invoice.move_type:
-                    key = invoice.fiscal_position_id.sii_registration_key_sale
-                else:
-                    key = invoice.fiscal_position_id.sii_registration_key_purchase
-                # Only assign sii_registration_key if it's set in the fiscal position
-                if key:
-                    invoice.sii_registration_key = key
-            else:
-                domain = [
-                    ("code", "=", "01"),
-                    ("type", "=", "sale" if "out" in invoice.move_type else "purchase"),
-                ]
-                sii_key_obj = self.env["aeat.sii.mapping.registration.keys"]
-                invoice.sii_registration_key = sii_key_obj.search(domain, limit=1)
+        return super()._compute_sii_registration_key()
 
     @api.depends("amount_total")
     def _compute_macrodata(self):
-        for inv in self:
-            inv.sii_macrodata = (
-                float_compare(
-                    abs(inv.amount_total_signed),
-                    SII_MACRODATA_LIMIT,
-                    precision_digits=2,
-                )
-                >= 0
-            )
+        return super()._compute_macrodata()
 
     def _sii_get_partner(self):
         return self.commercial_partner_id
@@ -292,67 +159,10 @@ class AccountMove(models.Model):
                     self._raise_exception_sii(_("invoice number"))
         return super().write(vals)
 
-    def unlink(self):
-        """A registered invoice at the SII cannot be deleted"""
-        for invoice in self.filtered(lambda x: x.is_invoice()):
-            if invoice.sii_state != "not_sent":
-                raise exceptions.UserError(
-                    _("You cannot delete an invoice already registered at the " "SII.")
-                )
-        return super().unlink()
-
-    def _get_sii_taxes_map(self, codes):
-        """Return the codes that correspond to that sii map line codes.
-
-        :param self: Single invoice record.
-        :param codes: List of code strings to get the mapping.
-        :return: Recordset with the corresponding codes
-        """
-        self.ensure_one()
-        map_obj = self.env["aeat.sii.map"].sudo()
-        sii_map = map_obj.search(
-            [
-                "|",
-                ("date_from", "<=", self.date),
-                ("date_from", "=", False),
-                "|",
-                ("date_to", ">=", self.date),
-                ("date_to", "=", False),
-            ],
-            limit=1,
-        )
-        tax_templates = sii_map.map_lines.filtered(lambda x: x.code in codes).taxes
-        return self.company_id.get_taxes_from_templates(tax_templates)
-
-    def _change_date_format(self, date):
-        datetimeobject = fields.Date.to_date(date)
-        new_date = datetimeobject.strftime("%d-%m-%Y")
-        return new_date
-
-    def _get_sii_header(self, tipo_comunicacion=False, cancellation=False):
-        """Builds SII send header
-
-        :param tipo_comunicacion String 'A0': new reg, 'A1': modification
-        :param cancellation Bool True when the communitacion es for invoice
-            cancellation
-        :return Dict with header data depending on cancellation
-        """
-        self.ensure_one()
-        company = self.company_id
-        if not company.vat:
-            raise exceptions.UserError(
-                _("No VAT configured for the company '{}'").format(company.name)
-            )
-        header = {
-            "IDVersionSii": SII_VERSION,
-            "Titular": {
-                "NombreRazon": self.company_id.name[0:120],
-                "NIF": company.partner_id._parse_aeat_vat_info()[2],
-            },
-        }
-        if not cancellation:
-            header.update({"TipoComunicacion": tipo_comunicacion})
-        return header
+    def _filter_sii_unlink_not_possible(self):
+        """Filter records that we can delete to apply only to invoices."""
+        res = super()._filter_sii_unlink_not_possible()
+        return res.filtered(lambda x: x.is_invoice())
 
     def _get_sii_tax_req(self, tax):
         """Get the associated req tax for the specified tax.
@@ -362,7 +172,7 @@ class AccountMove(models.Model):
         :return: REQ tax (or empty recordset) linked to the provided tax.
         """
         self.ensure_one()
-        taxes_req = self._get_sii_taxes_map(["RE"])
+        taxes_req = self._get_sii_taxes_map(["RE"], self._get_document_fiscal_date())
         re_lines = self.line_ids.filtered(
             lambda x: tax in x.tax_ids and x.tax_ids & taxes_req
         )
@@ -402,32 +212,8 @@ class AccountMove(models.Model):
             tax_dict["CuotaRecargoEquivalencia"] = tax_lines[req_tax]["amount"]
         return tax_dict
 
-    def _is_sii_type_breakdown_required(self, taxes_dict):
-        """Calculates if the block 'DesgloseTipoOperacion' is required for
-        the invoice communication."""
-        self.ensure_one()
-        if "DesgloseFactura" not in taxes_dict:
-            return False
-        country_code = self._get_sii_country_code()
-        sii_gen_type = self._get_sii_gen_type()
-        if "DesgloseTipoOperacion" in taxes_dict:
-            # DesgloseTipoOperacion and DesgloseFactura are Exclusive
-            return True
-        elif sii_gen_type in (2, 3):
-            # DesgloseTipoOperacion required for Intracommunity and
-            # Export operations
-            return True
-        elif sii_gen_type == 1 and country_code != "ES":
-            # DesgloseTipoOperacion required for national operations
-            # with 'IDOtro' in the SII identifier block
-            return True
-        elif sii_gen_type == 1 and (self._sii_get_partner().vat or "").startswith(
-            "ESN"
-        ):
-            # DesgloseTipoOperacion required if customer's country is Spain and
-            # has a NIF which starts with 'N'
-            return True
-        return False
+    def _get_document_amount_total(self):
+        return self.amount_total_signed
 
     def _get_sii_out_taxes(self):  # noqa: C901
         """Get the taxes for sales invoices.
@@ -436,17 +222,21 @@ class AccountMove(models.Model):
         """
         self.ensure_one()
         taxes_dict = {}
-        taxes_sfesb = self._get_sii_taxes_map(["SFESB"])
-        taxes_sfesbe = self._get_sii_taxes_map(["SFESBE"])
-        taxes_sfesisp = self._get_sii_taxes_map(["SFESISP"])
+        taxes_sfesb = self._get_sii_taxes_map(["SFESB"], self.date)
+        taxes_sfesbe = self._get_sii_taxes_map(["SFESBE"], self.date)
+        taxes_sfesisp = self._get_sii_taxes_map(["SFESISP"], self.date)
         # taxes_sfesisps = self._get_taxes_map(['SFESISPS'])
-        taxes_sfens = self._get_sii_taxes_map(["SFENS"])
-        taxes_sfess = self._get_sii_taxes_map(["SFESS"])
-        taxes_sfesse = self._get_sii_taxes_map(["SFESSE"])
-        taxes_sfesns = self._get_sii_taxes_map(["SFESNS"])
-        taxes_not_in_total = self._get_sii_taxes_map(["NotIncludedInTotal"])
-        taxes_not_in_total_neg = self._get_sii_taxes_map(["NotIncludedInTotalNegative"])
-        base_not_in_total = self._get_sii_taxes_map(["BaseNotIncludedInTotal"])
+        taxes_sfens = self._get_sii_taxes_map(["SFENS"], self.date)
+        taxes_sfess = self._get_sii_taxes_map(["SFESS"], self.date)
+        taxes_sfesse = self._get_sii_taxes_map(["SFESSE"], self.date)
+        taxes_sfesns = self._get_sii_taxes_map(["SFESNS"], self.date)
+        taxes_not_in_total = self._get_sii_taxes_map(["NotIncludedInTotal"], self.date)
+        taxes_not_in_total_neg = self._get_sii_taxes_map(
+            ["NotIncludedInTotalNegative"], self.date
+        )
+        base_not_in_total = self._get_sii_taxes_map(
+            ["BaseNotIncludedInTotal"], self.date
+        )
         not_in_amount_total = 0
         exempt_cause = self._get_sii_exempt_cause(taxes_sfesbe + taxes_sfesse)
         tax_lines = self._get_aeat_tax_info()
@@ -565,15 +355,19 @@ class AccountMove(models.Model):
         """
         self.ensure_one()
         taxes_dict = {}
-        taxes_sfrs = self._get_sii_taxes_map(["SFRS"])
-        taxes_sfrsa = self._get_sii_taxes_map(["SFRSA"])
-        taxes_sfrisp = self._get_sii_taxes_map(["SFRISP"])
-        taxes_sfrns = self._get_sii_taxes_map(["SFRNS"])
-        taxes_sfrnd = self._get_sii_taxes_map(["SFRND"])
-        taxes_sfrbi = self._get_sii_taxes_map(["SFRBI"])
-        taxes_not_in_total = self._get_sii_taxes_map(["NotIncludedInTotal"])
-        taxes_not_in_total_neg = self._get_sii_taxes_map(["NotIncludedInTotalNegative"])
-        base_not_in_total = self._get_sii_taxes_map(["BaseNotIncludedInTotal"])
+        taxes_sfrs = self._get_sii_taxes_map(["SFRS"], self.date)
+        taxes_sfrsa = self._get_sii_taxes_map(["SFRSA"], self.date)
+        taxes_sfrisp = self._get_sii_taxes_map(["SFRISP"], self.date)
+        taxes_sfrns = self._get_sii_taxes_map(["SFRNS"], self.date)
+        taxes_sfrnd = self._get_sii_taxes_map(["SFRND"], self.date)
+        taxes_sfrbi = self._get_sii_taxes_map(["SFRBI"], self.date)
+        taxes_not_in_total = self._get_sii_taxes_map(["NotIncludedInTotal"], self.date)
+        taxes_not_in_total_neg = self._get_sii_taxes_map(
+            ["NotIncludedInTotalNegative"], self.date
+        )
+        base_not_in_total = self._get_sii_taxes_map(
+            ["BaseNotIncludedInTotal"], self.date
+        )
         tax_amount = 0.0
         not_in_amount_total = 0.0
         tax_lines = self._get_aeat_tax_info()
@@ -617,157 +411,88 @@ class AccountMove(models.Model):
                     base_dict["DetalleIVA"].append(tax_dict)
         return taxes_dict, tax_amount, not_in_amount_total
 
-    def _is_sii_simplified_invoice(self):
-        """Inheritable method to allow control when an
-        invoice are simplified or normal"""
-        partner = self._sii_get_partner()
-        is_simplified = partner.sii_simplified_invoice
-        return is_simplified
+    def _get_mapping_key(self):
+        return self.move_type
 
     def _sii_check_exceptions(self):
-        """Inheritable method for exceptions control when sending SII invoices."""
-        self.ensure_one()
-        gen_type = self._get_sii_gen_type()
-        partner = self._sii_get_partner()
-        country_code = self._get_sii_country_code()
+        res = super()._sii_check_exceptions()
         is_simplified_invoice = self._is_sii_simplified_invoice()
-
         if is_simplified_invoice and self.move_type[:2] == "in":
             raise exceptions.UserError(
                 _("You can't make a supplier simplified invoice.")
             )
-        if (
-            (gen_type != 3 or country_code == "ES")
-            and not partner.vat
-            and not is_simplified_invoice
-        ):
-            raise exceptions.UserError(_("The partner has not a VAT configured."))
-        if not self.company_id.chart_template_id:
-            raise exceptions.UserError(
-                _("You have to select what account chart template use this" " company.")
-            )
-        if not self.company_id.sii_enabled:
-            raise exceptions.UserError(_("This company doesn't have SII enabled."))
-        if not self.sii_enabled:
-            raise exceptions.UserError(_("This invoice is not SII enabled."))
         if not self.ref and self.move_type in ["in_invoice", "in_refund"]:
             raise exceptions.UserError(_("The supplier number invoice is required"))
-
-    def _get_account_registration_date(self):
-        """Hook method to allow the setting of the account registration date
-        of each supplier invoice. The SII recommends to set the send date as
-        the default value (point 9.3 of the document
-        SII_Descripcion_ServicioWeb_v0.7.pdf), so by default we return
-        the current date or, if exists, the stored
-        sii_account_registration_date
-        :return String date in the format %Y-%m-%d"""
-        self.ensure_one()
-        return self.sii_account_registration_date or fields.Date.today()
+        return res
 
     def _get_sii_invoice_type(self):
-        tipo_factura = ""
+        invoice_type = ""
         if self.sii_lc_operation:
             return "LC"
         if self.move_type in ["in_invoice", "in_refund"]:
-            tipo_factura = "R4" if self.move_type == "in_refund" else "F1"
+            invoice_type = "R4" if self.move_type == "in_refund" else "F1"
         elif self.move_type in ["out_invoice", "out_refund"]:
             is_simplified = self._is_sii_simplified_invoice()
-            tipo_factura = "F2" if is_simplified else "F1"
+            invoice_type = "F2" if is_simplified else "F1"
             if self.move_type == "out_refund":
                 if self.sii_refund_specific_invoice_type:
-                    tipo_factura = self.sii_refund_specific_invoice_type
+                    invoice_type = self.sii_refund_specific_invoice_type
                 else:
-                    tipo_factura = "R5" if is_simplified else "R1"
-        return tipo_factura
+                    invoice_type = "R5" if is_simplified else "R1"
+        return invoice_type
 
     def _get_sii_invoice_dict_out(self, cancel=False):
-        """Build dict with data to send to AEAT WS for invoice types:
-        out_invoice and out_refund.
-
-        :param cancel: It indicates if the dictionary is for sending a
-          cancellation of the invoice.
-        :return: invoices (dict) : Dict XML with data for this invoice.
-        """
-        self.ensure_one()
-        invoice_date = self._change_date_format(self.invoice_date)
-        partner = self._sii_get_partner()
-        company = self.company_id
-        ejercicio = fields.Date.to_date(self.date).year
-        periodo = "%02d" % fields.Date.to_date(self.date).month
-        is_simplified_invoice = self._is_sii_simplified_invoice()
-        serial_number = (self.name or "")[0:60]
+        inv_dict = super()._get_sii_invoice_dict_out(cancel=cancel)
         if self.thirdparty_invoice:
-            serial_number = self.thirdparty_number[0:60]
-        inv_dict = {
-            "IDFactura": {
-                "IDEmisorFactura": {
-                    "NIF": company.partner_id._parse_aeat_vat_info()[2]
-                },
-                # On cancelled invoices, number is not filled
-                "NumSerieFacturaEmisor": serial_number,
-                "FechaExpedicionFacturaEmisor": invoice_date,
-            },
-            "PeriodoLiquidacion": {"Ejercicio": ejercicio, "Periodo": periodo},
-        }
-        if not cancel:
-            tipo_desglose, not_in_amount_total = self._get_sii_out_taxes()
-            amount_total = self.amount_total_signed - not_in_amount_total
-            inv_dict["FacturaExpedida"] = {
-                "TipoFactura": self._get_sii_invoice_type(),
-                "ClaveRegimenEspecialOTrascendencia": (self.sii_registration_key.code),
-                "DescripcionOperacion": self.sii_description,
-                "TipoDesglose": tipo_desglose,
-                "ImporteTotal": amount_total,
-            }
-            if self.thirdparty_invoice:
-                inv_dict["FacturaExpedida"]["EmitidaPorTercerosODestinatario"] = "S"
-            if self.sii_macrodata:
-                inv_dict["FacturaExpedida"].update(Macrodato="S")
-            if self.sii_registration_key_additional1:
-                inv_dict["FacturaExpedida"].update(
-                    {
-                        "ClaveRegimenEspecialOTrascendenciaAdicional1": (
-                            self.sii_registration_key_additional1.code
-                        )
-                    }
-                )
-            if self.sii_registration_key_additional2:
-                inv_dict["FacturaExpedida"].update(
-                    {
-                        "ClaveRegimenEspecialOTrascendenciaAdicional2": (
-                            self.sii_registration_key_additional2.code
-                        )
-                    }
-                )
-            if self.sii_registration_key.code in ["12", "13"]:
-                inv_dict["FacturaExpedida"]["DatosInmueble"] = {
-                    "DetalleInmueble": {
-                        "SituacionInmueble": self.sii_property_location,
-                        "ReferenciaCatastral": (
-                            self.sii_property_cadastrial_code or ""
-                        ),
-                    }
+            inv_dict["FacturaExpedida"]["EmitidaPorTercerosODestinatario"] = "S"
+        if self.sii_registration_key_additional1:
+            inv_dict["FacturaExpedida"].update(
+                {
+                    "ClaveRegimenEspecialOTrascendenciaAdicional1": (
+                        self.sii_registration_key_additional1.code
+                    )
                 }
-            exp_dict = inv_dict["FacturaExpedida"]
-            if not is_simplified_invoice:
-                # Simplified invoices don't have counterpart
-                exp_dict["Contraparte"] = {
-                    "NombreRazon": partner.name[0:120],
+            )
+        if self.sii_registration_key_additional2:
+            inv_dict["FacturaExpedida"].update(
+                {
+                    "ClaveRegimenEspecialOTrascendenciaAdicional2": (
+                        self.sii_registration_key_additional2.code
+                    )
+                }
+            )
+        if self.sii_registration_key.code in ["12", "13"]:
+            inv_dict["FacturaExpedida"]["DatosInmueble"] = {
+                "DetalleInmueble": {
+                    "SituacionInmueble": self.sii_property_location,
+                    "ReferenciaCatastral": (self.sii_property_cadastrial_code or ""),
+                }
+            }
+        exp_dict = inv_dict["FacturaExpedida"]
+        if self.move_type == "out_refund":
+            exp_dict["TipoRectificativa"] = self.sii_refund_type
+            if self.sii_refund_type == "S":
+                origin = self.refund_invoice_id
+                exp_dict["ImporteRectificacion"] = {
+                    "BaseRectificada": abs(origin.amount_untaxed_signed),
+                    "CuotaRectificada": abs(
+                        origin.amount_total_signed - origin.amount_untaxed_signed
+                    ),
                 }
-                # Uso condicional de IDOtro/NIF
-                exp_dict["Contraparte"].update(self._get_sii_identifier())
-            if self.move_type == "out_refund":
-                exp_dict["TipoRectificativa"] = self.sii_refund_type
-                if self.sii_refund_type == "S":
-                    origin = self.refund_invoice_id
-                    exp_dict["ImporteRectificacion"] = {
-                        "BaseRectificada": abs(origin.amount_untaxed_signed),
-                        "CuotaRectificada": abs(
-                            origin.amount_total_signed - origin.amount_untaxed_signed
-                        ),
-                    }
         return inv_dict
 
+    def _get_document_date(self):
+        return self.invoice_date
+
+    def _get_document_fiscal_date(self):
+        return self.date
+
+    def _get_document_serial_number(self):
+        serial_number = (self.name or "")[0:60]
+        if self.thirdparty_invoice:
+            serial_number = self.thirdparty_number[0:60]
+        return serial_number
+
     def _get_sii_invoice_dict_in(self, cancel=False):
         """Build dict with data to send to AEAT WS for invoice types:
         in_invoice and in_refund.
@@ -844,33 +569,6 @@ class AccountMove(models.Model):
                     }
         return inv_dict
 
-    def _get_sii_invoice_dict(self):
-        self.ensure_one()
-        self._sii_check_exceptions()
-        inv_dict = {}
-        if self.move_type in ["out_invoice", "out_refund"]:
-            inv_dict = self._get_sii_invoice_dict_out()
-        elif self.move_type in ["in_invoice", "in_refund"]:
-            inv_dict = self._get_sii_invoice_dict_in()
-        round_by_keys(
-            inv_dict,
-            [
-                "BaseImponible",
-                "CuotaRepercutida",
-                "CuotaSoportada",
-                "TipoRecargoEquivalencia",
-                "CuotaRecargoEquivalencia",
-                "ImportePorArticulos7_14_Otros",
-                "ImporteTAIReglasLocalizacion",
-                "ImporteTotal",
-                "BaseRectificada",
-                "CuotaRectificada",
-                "CuotaDeducible",
-                "ImporteCompensacionREAGYP",
-            ],
-        )
-        return inv_dict
-
     def _get_cancel_sii_invoice_dict(self):
         self.ensure_one()
         self._sii_check_exceptions()
@@ -880,136 +578,6 @@ class AccountMove(models.Model):
             return self._get_sii_invoice_dict_in(cancel=True)
         return {}
 
-    def _connect_params_sii(self, mapping_key):
-        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_sii(mapping_key, self.company_id)
-
-    def _connect_sii(self, mapping_key):
-        self.ensure_one()
-        public_crt, private_key = self.env["l10n.es.aeat.certificate"].get_certificates(
-            company=self.company_id
-        )
-        params = self._connect_params_sii(mapping_key)
-        session = Session()
-        session.cert = (public_crt, private_key)
-        transport = Transport(session=session)
-        history = HistoryPlugin()
-        client = Client(wsdl=params["wsdl"], transport=transport, plugins=[history])
-        return self._bind_sii(client, params["port_name"], params["address"])
-
-    def _bind_sii(self, client, port_name, address=None):
-        self.ensure_one()
-        service = client._get_service("siiService")
-        port = client._get_port(service, port_name)
-        address = address or port.binding_options["address"]
-        return client.create_service(port.binding.name, address)
-
-    def _process_invoice_for_sii_send(self):
-        """Process invoices for sending to the SII. Adds general checks from
-        configuration parameters and invoice availability for SII. If the
-        invoice is to be sent the decides the send method: direct send or
-        via connector depending on 'Use connector' configuration"""
-        queue_obj = self.env["queue.job"].sudo()
-        for invoice in self:
-            company = invoice.company_id
-            if not company.use_connector:
-                invoice._send_invoice_to_sii()
-            else:
-                eta = company._get_sii_eta()
-                new_delay = (
-                    invoice.sudo()
-                    .with_context(company_id=company.id)
-                    .with_delay(eta=eta if not invoice.sii_send_failed else False)
-                    .confirm_one_invoice()
-                )
-                job = queue_obj.search([("uuid", "=", new_delay.uuid)], limit=1)
-                invoice.sudo().invoice_jobs_ids |= job
-
-    def _send_invoice_to_sii(self):
-        for invoice in self.filtered(lambda i: i.state in SII_VALID_INVOICE_STATES):
-            serv = invoice._connect_sii(invoice.move_type)
-            if invoice.sii_state == "not_sent":
-                tipo_comunicacion = "A0"
-            else:
-                tipo_comunicacion = "A1"
-            header = invoice._get_sii_header(tipo_comunicacion)
-            inv_vals = {
-                "sii_header_sent": json.dumps(header, indent=4),
-            }
-            try:
-                inv_dict = invoice._get_sii_invoice_dict()
-                inv_vals["sii_content_sent"] = json.dumps(inv_dict, indent=4)
-                if invoice.move_type in ["out_invoice", "out_refund"]:
-                    res = serv.SuministroLRFacturasEmitidas(header, inv_dict)
-                elif invoice.move_type in ["in_invoice", "in_refund"]:
-                    res = serv.SuministroLRFacturasRecibidas(header, inv_dict)
-                # TODO Facturas intracomunitarias 66 RIVA
-                # elif invoice.fiscal_position_id.id == self.env.ref(
-                #     'account.fp_intra').id:
-                #     res = serv.SuministroLRDetOperacionIntracomunitaria(
-                #         header, invoices)
-                res_line = res["RespuestaLinea"][0]
-                if res["EstadoEnvio"] == "Correcto":
-                    inv_vals.update(
-                        {
-                            "sii_state": "sent",
-                            "sii_csv": res["CSV"],
-                            "sii_send_failed": False,
-                        }
-                    )
-                elif (
-                    res["EstadoEnvio"] == "ParcialmenteCorrecto"
-                    and res_line["EstadoRegistro"] == "AceptadoConErrores"
-                ):
-                    inv_vals.update(
-                        {
-                            "sii_state": "sent_w_errors",
-                            "sii_csv": res["CSV"],
-                            "sii_send_failed": True,
-                        }
-                    )
-                else:
-                    inv_vals["sii_send_failed"] = True
-                if (
-                    "sii_state" in inv_vals
-                    and not invoice.sii_account_registration_date
-                    and invoice.move_type[:2] == "in"
-                ):
-                    inv_vals[
-                        "sii_account_registration_date"
-                    ] = self._get_account_registration_date()
-                inv_vals["sii_return"] = res
-                send_error = False
-                if res_line["CodigoErrorRegistro"]:
-                    send_error = "{} | {}".format(
-                        str(res_line["CodigoErrorRegistro"]),
-                        str(res_line["DescripcionErrorRegistro"])[:60],
-                    )
-                inv_vals["sii_send_error"] = send_error
-                invoice.write(inv_vals)
-            except Exception as fault:
-                new_cr = Registry(self.env.cr.dbname).cursor()
-                env = api.Environment(new_cr, self.env.uid, self.env.context)
-                invoice = env["account.move"].browse(invoice.id)
-                inv_vals.update(
-                    {
-                        "sii_send_failed": True,
-                        "sii_send_error": repr(fault)[:60],
-                        "sii_return": repr(fault),
-                    }
-                )
-                invoice.write(inv_vals)
-                new_cr.commit()
-                new_cr.close()
-                raise
-
     def _sii_invoice_dict_not_modified(self):
         self.ensure_one()
         to_send = self._get_sii_invoice_dict()
@@ -1033,7 +601,7 @@ class AccountMove(models.Model):
             company = invoice.company_id
             if company.sii_method != "auto":
                 continue
-            invoice._process_invoice_for_sii_send()
+            invoice._process_sii_send()
         return res
 
     def process_send_sii(self):
@@ -1047,22 +615,11 @@ class AccountMove(models.Model):
             "context": self.env.context,
         }
 
-    def send_sii(self):
-        invoices = self.filtered(
-            lambda i: (
-                i.sii_enabled
-                and i.state in SII_VALID_INVOICE_STATES
-                and i.sii_state not in ["sent", "cancelled"]
-            )
-        )
-        if not invoices._cancel_invoice_jobs():
-            raise exceptions.UserError(
-                _(
-                    "You can not communicate this invoice at this moment "
-                    "because there is a job running!"
-                )
-            )
-        invoices._process_invoice_for_sii_send()
+    def _get_sii_jobs_field_name(self):
+        return "invoice_jobs_ids"
+
+    def _get_valid_document_states(self):
+        return SII_VALID_INVOICE_STATES
 
     def _cancel_invoice_to_sii(self):
         for invoice in self.filtered(lambda i: i.state in ["cancel"]):
@@ -1123,7 +680,7 @@ class AccountMove(models.Model):
                 and i.sii_state in ["sent", "sent_w_errors", "sent_modified"]
             )
         )
-        if not invoices._cancel_invoice_jobs():
+        if not invoices._cancel_sii_jobs():
             raise exceptions.UserError(
                 _(
                     "You can not communicate the cancellation of this invoice "
@@ -1146,16 +703,8 @@ class AccountMove(models.Model):
                 job = queue_obj.search([("uuid", "=", new_delay.uuid)], limit=1)
                 invoice.sudo().invoice_jobs_ids |= job
 
-    def _cancel_invoice_jobs(self):
-        for queue in self.sudo().mapped("invoice_jobs_ids"):
-            if queue.state == "started":
-                return False
-            elif queue.state in ("pending", "enqueued", "failed"):
-                queue.unlink()
-        return True
-
     def button_cancel(self):
-        if not self._cancel_invoice_jobs():
+        if not self._cancel_sii_jobs():
             raise exceptions.UserError(
                 _("You can not cancel this invoice because" " there is a job running!")
             )
@@ -1170,7 +719,7 @@ class AccountMove(models.Model):
         return res
 
     def button_draft(self):
-        if not self._cancel_invoice_jobs():
+        if not self._cancel_sii_jobs():
             raise exceptions.UserError(
                 _(
                     "You can not set to draft this invoice because"
@@ -1179,126 +728,17 @@ class AccountMove(models.Model):
             )
         return super().button_draft()
 
-    def _get_sii_gen_type(self):
-        """Make a choice for general invoice type
-
-        Returns:
-            int: 1 (National), 2 (Intracom), 3 (Export)
-        """
-        self.ensure_one()
-        partner_ident = self.fiscal_position_id.sii_partner_identification_type
-        if partner_ident:
-            res = int(partner_ident)
-        elif self.fiscal_position_id.name == "Régimen Intracomunitario":
-            res = 2
-        elif self.fiscal_position_id.name == "Régimen Extracomunitario":
-            res = 3
-        else:
-            res = 1
-        return res
-
-    def _get_sii_identifier(self):
-        """Get the SII structure for a partner identifier depending on the
-        conditions of the invoice.
-        """
-        self.ensure_one()
-        gen_type = self._get_sii_gen_type()
-        (
-            country_code,
-            identifier_type,
-            identifier,
-        ) = self._sii_get_partner()._parse_aeat_vat_info()
-        # Limpiar alfanum
-        if identifier:
-            identifier = "".join(e for e in identifier if e.isalnum()).upper()
-        else:
-            identifier = "NO_DISPONIBLE"
-            identifier_type = "06"
-        if gen_type == 1:
-            if "1117" in (self.sii_send_error or ""):
-                return {
-                    "IDOtro": {
-                        "CodigoPais": country_code,
-                        "IDType": "07",
-                        "ID": identifier,
-                    }
-                }
-            else:
-                if identifier_type == "":
-                    return {"NIF": identifier}
-                return {
-                    "IDOtro": {
-                        "CodigoPais": country_code,
-                        "IDType": identifier_type,
-                        "ID": country_code + identifier
-                        if self.commercial_partner_id._map_aeat_country_code(
-                            country_code
-                        )
-                        in self.commercial_partner_id._get_aeat_europe_codes()
-                        else identifier,
-                    },
-                }
-        elif gen_type == 2:
-            return {"IDOtro": {"IDType": "02", "ID": country_code + identifier}}
-        elif gen_type == 3 and identifier_type:
-            # Si usamos identificador tipo 02 en exportaciones, el envío falla con:
-            #   {'CodigoErrorRegistro': 1104,
-            #    'DescripcionErrorRegistro': 'Valor del campo ID incorrecto'}
-            if identifier_type == "02":
-                identifier_type = "06"
-            return {
-                "IDOtro": {
-                    "CodigoPais": country_code,
-                    "IDType": identifier_type,
-                    "ID": identifier,
-                },
-            }
-        elif gen_type == 3:
-            return {"NIF": identifier}
-
-    def _get_sii_exempt_cause(self, applied_taxes):
-        """Código de la causa de exención según 3.6 y 3.7 de la FAQ del SII.
-
-        :param applied_taxes: Taxes that are exempt for filtering the lines.
-        """
-        self.ensure_one()
-        gen_type = self._get_sii_gen_type()
-        if gen_type == 2:
-            return "E5"
-        else:
-            exempt_cause = False
-            product_exempt_causes = (
-                self.mapped("invoice_line_ids")
-                .filtered(
-                    lambda x: (
-                        any(tax in x.tax_ids for tax in applied_taxes)
-                        and x.product_id.sii_exempt_cause
-                        and x.product_id.sii_exempt_cause != "none"
-                    )
+    def _get_document_product_exempt(self, applied_taxes):
+        return set(
+            self.mapped("invoice_line_ids")
+            .filtered(
+                lambda x: (
+                    any(tax in x.tax_ids for tax in applied_taxes)
+                    and x.product_id.sii_exempt_cause
+                    and x.product_id.sii_exempt_cause != "none"
                 )
-                .mapped("product_id.sii_exempt_cause")
             )
-            product_exempt_causes = set(product_exempt_causes)
-            if len(product_exempt_causes) > 1:
-                raise exceptions.UserError(
-                    _("Currently there's no support for multiple exempt " "causes.")
-                )
-            if product_exempt_causes:
-                exempt_cause = product_exempt_causes.pop()
-            elif (
-                self.fiscal_position_id.sii_exempt_cause
-                and self.fiscal_position_id.sii_exempt_cause != "none"
-            ):
-                exempt_cause = self.fiscal_position_id.sii_exempt_cause
-            if gen_type == 3 and exempt_cause not in ["E2", "E3"]:
-                exempt_cause = "E2"
-            return exempt_cause
-
-    def _get_no_taxable_cause(self):
-        self.ensure_one()
-        return (
-            self.fiscal_position_id.sii_no_taxable_cause
-            or "ImporteTAIReglasLocalizacion"
+            .mapped("product_id.sii_exempt_cause")
         )
 
     def is_sii_invoice(self):
@@ -1310,10 +750,6 @@ class AccountMove(models.Model):
         """
         self.ensure_one()
 
-    def _get_sii_country_code(self):
-        self.ensure_one()
-        return self._sii_get_partner()._parse_aeat_vat_info()[0]
-
     @api.depends(
         "invoice_line_ids",
         "invoice_line_ids.name",
@@ -1386,8 +822,5 @@ class AccountMove(models.Model):
         )
         return res
 
-    def confirm_one_invoice(self):
-        self.sudo()._send_invoice_to_sii()
-
     def cancel_one_invoice(self):
         self.sudo()._cancel_invoice_to_sii()