|
|
@@ -0,0 +1,831 @@
|
|
|
+from odoo import api, fields, models, _, Command
|
|
|
+from odoo.exceptions import ValidationError
|
|
|
+from collections import OrderedDict
|
|
|
+from datetime import date
|
|
|
+from os.path import basename
|
|
|
+from zipfile import ZipFile
|
|
|
+from tempfile import TemporaryDirectory
|
|
|
+import xmltodict
|
|
|
+import base64
|
|
|
+import logging
|
|
|
+import os.path
|
|
|
+
|
|
|
+_logger = logging.getLogger(__name__)
|
|
|
+
|
|
|
+
|
|
|
+class AccountCFDI(models.Model):
|
|
|
+ _name = 'account.cfdi'
|
|
|
+ _inherit = ['mail.thread', 'mail.activity.mixin']
|
|
|
+ _description = 'Complemento CFDI'
|
|
|
+
|
|
|
+ code = fields.Char(string="Código")
|
|
|
+ name = fields.Char(string="Referencia")
|
|
|
+ uuid = fields.Char(string="UUID")
|
|
|
+ certificate = fields.Char(string="Certificado")
|
|
|
+ certificate_number = fields.Char(string="Nro. de certificado")
|
|
|
+ serie = fields.Char(string="Serie")
|
|
|
+ folio = fields.Char(string="Folio")
|
|
|
+ stamp = fields.Char(string="Sello")
|
|
|
+ version = fields.Char(string="Versión")
|
|
|
+ payment_condition = fields.Char(string="Condiciones de pago")
|
|
|
+ currency = fields.Char(string="Moneda")
|
|
|
+ payment_method = fields.Char(string="Forma de pago")
|
|
|
+ location = fields.Char(string="Lugar de expedición")
|
|
|
+ observations = fields.Text(string='Notas')
|
|
|
+ attachment_id = fields.Many2one(comodel_name="ir.attachment", string="Archivo adjunto")
|
|
|
+ pdf_id = fields.Many2one(comodel_name="ir.attachment", string="Representación impresa")
|
|
|
+ company_id = fields.Many2one(comodel_name="res.company", string="Empresa", default=lambda self: self.env.company)
|
|
|
+ emitter_id = fields.Many2one(comodel_name="res.partner", string="Emisor")
|
|
|
+ receiver_id = fields.Many2one(comodel_name="res.partner", string="Receptor")
|
|
|
+ move_id = fields.Many2one(comodel_name="account.move", string="Movimiento contable", copy=False)
|
|
|
+ payable_account_id = fields.Many2one(comodel_name='account.account', string='Cuenta contable a pagar', tracking=True)
|
|
|
+ account_id = fields.Many2one(comodel_name='account.account', string='Cuenta contable gasto', tracking=True)
|
|
|
+ account_analytic_account_id = fields.Many2one(comodel_name='account.analytic.account', string='Cuenta analítica')
|
|
|
+ fiscal_position_id = fields.Many2one(comodel_name='account.fiscal.position', string='Posición fiscal')
|
|
|
+ journal_id = fields.Many2one(comodel_name='account.journal', string='Diario', tracking=True)
|
|
|
+ tax_isr_id = fields.Many2one(comodel_name='account.tax', string='Retención ISR')
|
|
|
+ tax_iva_id = fields.Many2one(comodel_name='account.tax', string='Retención IVA')
|
|
|
+ analytic_distribution = fields.Json(string="Distribución analítica")
|
|
|
+ analytic_precision = fields.Integer(string="Precisión analítica", store=False, default=lambda self: self.env['decimal.precision'].precision_get("Percentage Analytic"))
|
|
|
+ concept_ids = fields.One2many("account.cfdi.line", "cfdi_id", string="Conceptos")
|
|
|
+ tax_ids = fields.One2many('account.cfdi.tax', 'cfdi_id', string='Impuestos')
|
|
|
+ date = fields.Date(string="Fecha")
|
|
|
+ subtotal = fields.Float(string="Subtotal", copy=False)
|
|
|
+ total = fields.Float(string="Total", copy=False)
|
|
|
+ tax_total = fields.Float(string="Impuestos", compute="compute_tax_total", store=True)
|
|
|
+ payment_type = fields.Selection(selection=[('PPD', 'PPD'), ('PUE', 'PUE')], string='Método de pago', readonly=True)
|
|
|
+ cfdi_type = fields.Selection(string="Tipo de comprobante", selection=[
|
|
|
+ ('I', 'Facturas de clientes'),
|
|
|
+ ('SI', 'Facturas de proveedor'),
|
|
|
+ ('E', 'Notas de crédito cliente'),
|
|
|
+ ('SE', 'Notas de crédito proveedor'),
|
|
|
+ ('P', 'REP de clientes'),
|
|
|
+ ('SP', 'REP de proveedores'),
|
|
|
+ ('N', 'Nóminas de empleados'),
|
|
|
+ ('SN', 'Nómina propia'),
|
|
|
+ ('T', 'Factura de traslado cliente'),
|
|
|
+ ('ST', 'Factura de traslado proveedor')
|
|
|
+ ], index=True, copy=False)
|
|
|
+ state = fields.Selection(string="Estado", selection=[
|
|
|
+ ('draft', 'Borrador'),
|
|
|
+ ('done', 'Procesada'),
|
|
|
+ ('cancel', 'Anulado')
|
|
|
+ ], copy=False, default='draft', tracking=True)
|
|
|
+ sat_state = fields.Selection(string="Estado SAT", selection=[
|
|
|
+ ("valid", "Valido"),
|
|
|
+ ("not_found", "No Encontrado"),
|
|
|
+ ("undefined", "No sincronizado Aún"),
|
|
|
+ ("none", "Estado no definido"),
|
|
|
+ ("cancelled", "Cancelado")
|
|
|
+ ], copy=False, tracking=True, default="valid")
|
|
|
+ #Datos de addenda
|
|
|
+ delivery_number = fields.Char(string="No. Entrega")
|
|
|
+ invoice_qty = fields.Integer(string="Unidades facturadas")
|
|
|
+
|
|
|
+ @api.depends("subtotal","total")
|
|
|
+ def compute_tax_total(self):
|
|
|
+ for rec in self:
|
|
|
+ rec.tax_total = rec.total - rec.subtotal
|
|
|
+
|
|
|
+ # ---------------------------------------------------Metodos de creación---------------------------------------------------------
|
|
|
+
|
|
|
+ @api.model
|
|
|
+ def create(self, vals_list):
|
|
|
+ self = self.with_context(skip_invoice_sync=True, check_move_validity=False)
|
|
|
+ res = super().create(vals_list)
|
|
|
+ for cfdi in res.filtered(lambda move: move.move_id):
|
|
|
+ cfdi.move_id.update({
|
|
|
+ "cfdi_id": cfdi.id
|
|
|
+ })
|
|
|
+ return res
|
|
|
+
|
|
|
+ def name_get(self):
|
|
|
+ result = []
|
|
|
+ for record in self:
|
|
|
+ folio = f"[{record.serie}-{record.folio}] - " if record.serie and record.folio else f"[{record.serie}] - " if record.serie and not record.folio else f"[{record.folio}] - " if not record.serie and record.folio else ""
|
|
|
+ name = f"{folio}" + record.uuid + ' - $' + str(record.total)
|
|
|
+ result.append((record.id, name))
|
|
|
+ return result
|
|
|
+
|
|
|
+ # Creación de CFDIS
|
|
|
+ def create_cfdis(self, attachment_data):
|
|
|
+ self = self.with_context(skip_invoice_sync=True, check_move_validity=False)
|
|
|
+ cfdi_list = []
|
|
|
+ cfdi_ids = self.env["account.cfdi"]
|
|
|
+ uuids = []
|
|
|
+ for data in attachment_data:
|
|
|
+ # Obtener la información para crear el cfdi
|
|
|
+ data_xml = data.get("xml")
|
|
|
+ xml_data = self.get_cfdi_data(data_xml.get("datas"))
|
|
|
+ if xml_data.get("Comprobante"):
|
|
|
+ cfdi_type = self.get_cfdi_type(xml_data)
|
|
|
+ uuid = self.validation_cfdi(xml_data, cfdi_type)
|
|
|
+ # Evitar UUID repetidos ya que el SAT manda en ocasiones el mismo XML dos veces
|
|
|
+ if uuid and uuid not in uuids:
|
|
|
+ uuids.append(uuid)
|
|
|
+ emiiter_partner_id, recipient_partner_id = self.get_cfdi_partners(xml_data)
|
|
|
+ move_id = self.validate_cfdi_move(xml_data, uuid, cfdi_type, emiiter_partner_id)
|
|
|
+ cfdi_data = self.add_cfdi_data(xml_data, uuid, emiiter_partner_id, recipient_partner_id, move_id, cfdi_type, data)
|
|
|
+ cfdi_data = self.get_cfdi_lines(xml_data, cfdi_data, cfdi_type, emiiter_partner_id, recipient_partner_id)
|
|
|
+ # cfdi_data = self.get_payment_tax(cfdi_type, xml_data, cfdi_data)
|
|
|
+ cfdi_list.append(cfdi_data)
|
|
|
+ else:
|
|
|
+ continue
|
|
|
+ if cfdi_list:
|
|
|
+ cfdi_ids = self.env["account.cfdi"].sudo().create(cfdi_list)
|
|
|
+ return cfdi_ids
|
|
|
+
|
|
|
+ # Obtener la información del xml
|
|
|
+ def get_cfdi_data(self, xml_file):
|
|
|
+ file_content = base64.b64decode(xml_file)
|
|
|
+ if b'xmlns:schemaLocation' in file_content and b'xsi:schemaLocation' not in file_content:
|
|
|
+ file_content = file_content.replace(b'xmlns:schemaLocation', b'xsi:schemaLocation')
|
|
|
+ file_content = file_content.replace(b'cfdi:', b'')
|
|
|
+ file_content = file_content.replace(b'tfd:', b'')
|
|
|
+ try:
|
|
|
+ xml_data = xmltodict.parse(file_content)
|
|
|
+ return xml_data
|
|
|
+ except Exception as e:
|
|
|
+ _logger.info(e)
|
|
|
+ return dict()
|
|
|
+
|
|
|
+ # Obtener el tipo de comprobante que es el CFDI
|
|
|
+ def get_cfdi_type(self, xml_data):
|
|
|
+ cfdi_type = xml_data['Comprobante']['@TipoDeComprobante'] if '@TipoDeComprobante' in xml_data['Comprobante'] else 'I'
|
|
|
+ if cfdi_type in ['I', 'E', 'P']:
|
|
|
+ if xml_data['Comprobante']['Emisor']['@Rfc'] != self.env.company.vat:
|
|
|
+ cfdi_type = 'S' + cfdi_type
|
|
|
+ return cfdi_type
|
|
|
+
|
|
|
+ # Validaciones antes de la creación del CFDI
|
|
|
+ def validation_cfdi(self, xml_data, cfdi_type):
|
|
|
+ if '@UUID' in xml_data['Comprobante']['Complemento']['TimbreFiscalDigital']:
|
|
|
+ uuid = xml_data['Comprobante']['Complemento']['TimbreFiscalDigital']['@UUID']
|
|
|
+ cfdi_id = self.env['account.cfdi'].sudo().search([('uuid', '=', uuid)], limit=1)
|
|
|
+ if cfdi_id:
|
|
|
+ _logger.info(f"El CFDI con UUID {uuid}, ya existe en la base de datos, se omitirá en el proceso.")
|
|
|
+ return False
|
|
|
+ # Evitar que se suban xml que no pertenecen a la empresa
|
|
|
+ if "S" in cfdi_type:
|
|
|
+ partner_rfc = xml_data['Comprobante']['Receptor']['@Rfc']
|
|
|
+ else:
|
|
|
+ partner_rfc = xml_data['Comprobante']['Emisor']['@Rfc']
|
|
|
+ if partner_rfc != self.env.company.vat:
|
|
|
+ return False
|
|
|
+ else:
|
|
|
+ return False
|
|
|
+ return uuid
|
|
|
+
|
|
|
+ # Buscar el asiento contable de odoo relacionado si es que existe
|
|
|
+ def validate_cfdi_move(self, xml_data, uuid, cfdi_type, emitter_partner_id):
|
|
|
+ move_id = self.env["account.move"]
|
|
|
+ delivery_number, invoice_qty = self.get_addenda_data(xml_data)
|
|
|
+ if cfdi_type in ["I", "E"]:
|
|
|
+ move_id = move_id.sudo().search(
|
|
|
+ [("move_type", "in", ["out_invoice", "out_refund"]), ("l10n_mx_edi_cfdi_uuid", "=", uuid),
|
|
|
+ ("state", "=", "posted"), ("cfdi_id", "=", False)], limit=1)
|
|
|
+ elif cfdi_type in ["SI", "SE"]:
|
|
|
+ invoice_date = xml_data['Comprobante']['@Fecha'] if '@Fecha' in xml_data['Comprobante'] else ""
|
|
|
+ folio = xml_data['Comprobante']['@Folio'] if '@Folio' in xml_data['Comprobante'] else ''
|
|
|
+ move_id = self.env['account.move'].sudo().search(
|
|
|
+ [('partner_id.vat', '=', emitter_partner_id.vat), ('ref', '=', folio),
|
|
|
+ ('move_type', 'in', ['in_invoice', 'in_refund']), ("state", "=", "posted"), ("cfdi_id", "=", False),
|
|
|
+ ("invoice_date", "=", invoice_date[:10])], limit=1)
|
|
|
+ if not move_id:
|
|
|
+ if '@Serie' in xml_data['Comprobante']:
|
|
|
+ folio = xml_data['Comprobante']['@Serie'] + folio
|
|
|
+ move_id = self.env['account.move'].sudo().search(
|
|
|
+ [('partner_id.vat', '=', emitter_partner_id.vat), ('ref', '=', folio),
|
|
|
+ ('move_type', 'in', ['in_invoice', 'in_refund']), ("cfdi_id", "=", False),
|
|
|
+ ("state", "=", "posted"), ("invoice_date", "=", invoice_date[:10])], limit=1)
|
|
|
+ if not move_id:
|
|
|
+ move_id = self.env['account.move'].sudo().search(
|
|
|
+ [('partner_id.vat', '=', emitter_partner_id.vat),
|
|
|
+ ('move_type', 'in', ['in_invoice', 'in_refund']), ("state", "=", "posted"),
|
|
|
+ ("cfdi_id", "=", False),
|
|
|
+ ("invoice_date", "=", invoice_date[:10])], limit=1)
|
|
|
+ if not move_id and delivery_number:
|
|
|
+ move_id = self.env['account.move'].sudo().search(
|
|
|
+ [('partner_id.vat', '=', emitter_partner_id.vat),
|
|
|
+ ('move_type', 'in', ['in_invoice', 'in_refund']), ("state", "=", "posted"),
|
|
|
+ ("cfdi_id", "=", False), ("x_delivery_number","!=",False),
|
|
|
+ ("x_delivery_number", "=", delivery_number)], limit=1)
|
|
|
+ if not move_id:
|
|
|
+ amount_untaxed = xml_data['Comprobante']['@SubTotal'] if '@SubTotal' in xml_data['Comprobante'] else 0
|
|
|
+ invoice_date = xml_data['Comprobante']['@Fecha'] if '@Fecha' in xml_data['Comprobante'] else ""
|
|
|
+ move_id = self.env['account.move'].sudo().search(
|
|
|
+ [('partner_id.vat', '=', emitter_partner_id.vat), ('move_type', 'in', ['in_invoice']),
|
|
|
+ ("cfdi_id", "=", False), ("state", "=", "posted"), ("amount_untaxed", "=", amount_untaxed),
|
|
|
+ ("invoice_date", "=", invoice_date[:10])], limit=1)
|
|
|
+ return move_id
|
|
|
+
|
|
|
+ # Preparar la informacion del CFDI
|
|
|
+ def add_cfdi_data(self, xml_data, uuid, emitter_partner_id, recipient_partner_id, move_id, cfdi_type, attachment_data):
|
|
|
+ journal_id, account_id = self.get_cfdi_journal_id(cfdi_type, emitter_partner_id, recipient_partner_id)
|
|
|
+ partner_id = recipient_partner_id if cfdi_type in ["I", "E"] else emitter_partner_id
|
|
|
+ payable_account_id = self.get_payable_cfdi_account_id(cfdi_type, partner_id)
|
|
|
+ attachment_id = self.env["ir.attachment"].sudo().create(attachment_data.get("xml"))
|
|
|
+ pdf_id = self.env["ir.attachment"].sudo().create(attachment_data.get("pdf")) if attachment_data.get("pdf") else False
|
|
|
+ delivery_number, invoice_qty = self.get_addenda_data(xml_data)
|
|
|
+
|
|
|
+ data = {
|
|
|
+ "attachment_id": attachment_id.id,
|
|
|
+ "pdf_id": pdf_id.id if pdf_id else False,
|
|
|
+ "code": uuid,
|
|
|
+ "uuid": uuid,
|
|
|
+ "certificate": xml_data['Comprobante']['@Certificado'] if '@Certificado' in xml_data['Comprobante'] else '',
|
|
|
+ "date": xml_data['Comprobante']['@Fecha'] if '@Fecha' in xml_data['Comprobante'] else '',
|
|
|
+ "folio": xml_data['Comprobante']['@Folio'] if '@Folio' in xml_data['Comprobante'] else '',
|
|
|
+ "payment_method": xml_data['Comprobante']['@FormaPago'] if '@FormaPago' in xml_data['Comprobante'] else '',
|
|
|
+ "location": xml_data['Comprobante']['@LugarExpedicion'] if '@LugarExpedicion' in xml_data['Comprobante'] else '',
|
|
|
+ "payment_type": xml_data['Comprobante']['@MetodoPago'] if '@MetodoPago' in xml_data['Comprobante'] else '',
|
|
|
+ "currency": xml_data['Comprobante']['@Moneda'] if '@Moneda' in xml_data['Comprobante'] else '',
|
|
|
+ "certificate_number": xml_data['Comprobante']['@NoCertificado'] if '@NoCertificado' in xml_data['Comprobante'] else '',
|
|
|
+ "stamp": xml_data['Comprobante']['@Sello'] if '@Sello' in xml_data['Comprobante'] else '',
|
|
|
+ "serie": xml_data['Comprobante']['@Serie'] if '@Serie' in xml_data['Comprobante'] else '',
|
|
|
+ "subtotal": xml_data['Comprobante']['@SubTotal'] if '@SubTotal' in xml_data['Comprobante'] else '',
|
|
|
+ "cfdi_type": cfdi_type,
|
|
|
+ "total": xml_data['Comprobante']['@Total'] if '@Total' in xml_data['Comprobante'] else '',
|
|
|
+ "version": xml_data['Comprobante']['@Version'] if '@Version' in xml_data['Comprobante'] else '',
|
|
|
+ "payment_condition": xml_data['Comprobante']['@CondicionesDePago'] if '@CondicionesDePago' in xml_data['Comprobante'] else '',
|
|
|
+ "emitter_id": emitter_partner_id.id,
|
|
|
+ "receiver_id": recipient_partner_id.id,
|
|
|
+ "move_id": move_id.id if move_id else False,
|
|
|
+ "state": "draft" if not move_id else "done",
|
|
|
+ "journal_id": journal_id.id if journal_id else False,
|
|
|
+ "account_id": account_id.id if account_id else False,
|
|
|
+ "fiscal_position_id": partner_id.property_account_position_id.id if partner_id.property_account_position_id else False,
|
|
|
+ "tax_iva_id": partner_id.x_tax_iva_id.id if partner_id.x_tax_iva_id else False,
|
|
|
+ "tax_isr_id": partner_id.x_tax_isr_id.id if partner_id.x_tax_isr_id else False,
|
|
|
+ "payable_account_id": payable_account_id.id if payable_account_id else False,
|
|
|
+ }
|
|
|
+ data["name"] = data["serie"] + data["folio"] if data.get("serie") and data.get("folio") else data["serie"] if data.get("serie") else data.get("folio")
|
|
|
+ data["delivery_number"] = delivery_number
|
|
|
+ data["invoice_qty"] = invoice_qty
|
|
|
+ return data
|
|
|
+
|
|
|
+ # Se obtienen las lineas de CFDI
|
|
|
+ def get_cfdi_lines(self, xml_data, cfdi_data, cfdi_type, emitter_partner_id, recipient_partner_id):
|
|
|
+ if type(xml_data['Comprobante']['Conceptos']['Concepto']) is list:
|
|
|
+ lines = xml_data['Comprobante']['Conceptos']['Concepto']
|
|
|
+ elif type(xml_data['Comprobante']['Conceptos']['Concepto']) is OrderedDict:
|
|
|
+ lines = xml_data['Comprobante']['Conceptos'].items()
|
|
|
+ else:
|
|
|
+ lines = [xml_data['Comprobante']['Conceptos']['Concepto']]
|
|
|
+ i = 1
|
|
|
+ data_list = []
|
|
|
+ for line_value in lines:
|
|
|
+ if type(xml_data['Comprobante']['Conceptos']['Concepto']) is list:
|
|
|
+ line = line_value
|
|
|
+ elif type(xml_data['Comprobante']['Conceptos']['Concepto']) is OrderedDict:
|
|
|
+ line = line_value[1]
|
|
|
+ else:
|
|
|
+ line = line_value
|
|
|
+ if float(line['@Importe']) >= 0:
|
|
|
+ uom_id = False
|
|
|
+ if '@ClaveUnidad' in line:
|
|
|
+ uom_unspsc_id = self.env['product.unspsc.code'].sudo().search([('code', '=', line['@ClaveUnidad'])])
|
|
|
+ if uom_unspsc_id:
|
|
|
+ uom_id = self.env['uom.uom'].sudo().search([('unspsc_code_id', '=', uom_unspsc_id.id)], limit=1)
|
|
|
+ if uom_id:
|
|
|
+ unidad_id = uom_id.id
|
|
|
+ else:
|
|
|
+ unidad_id = False
|
|
|
+ product_category_id = False
|
|
|
+ if '@ClaveProdServ' in line:
|
|
|
+ unspsc_product_category_id = self.env['product.unspsc.code'].sudo().search([('code', '=', line['@ClaveProdServ'])])
|
|
|
+ if unspsc_product_category_id:
|
|
|
+ product_category_id = unspsc_product_category_id.id
|
|
|
+ else:
|
|
|
+ product_category_id = False
|
|
|
+
|
|
|
+ data_line = {
|
|
|
+ 'sequence': i,
|
|
|
+ 'code_cfdi': cfdi_data.get("code"),
|
|
|
+ 'date': cfdi_data.get("date"),
|
|
|
+ 'folio': cfdi_data.get("folio"),
|
|
|
+ 'payment_method': cfdi_data.get("payment_method"),
|
|
|
+ 'location': cfdi_data.get("location"),
|
|
|
+ 'payment_type': cfdi_data.get("payment_type"),
|
|
|
+ 'currency': cfdi_data.get("currency"),
|
|
|
+ 'certificate_number': cfdi_data.get("certificate_number"),
|
|
|
+ 'stamp': cfdi_data.get("stamp"),
|
|
|
+ 'serie': cfdi_data.get("serie"),
|
|
|
+ 'subtotal': cfdi_data.get("subtotal"),
|
|
|
+ 'cfdi_type': cfdi_data.get("cfdi_type"),
|
|
|
+ 'total': cfdi_data.get("total"),
|
|
|
+ 'version': cfdi_data.get("version"),
|
|
|
+ 'emitter_id': cfdi_data.get("emitter_id"),
|
|
|
+ 'receiver_id': cfdi_data.get("receiver_id"),
|
|
|
+ 'product_code': line['@ClaveProdServ'] if '@ClaveProdServ' in line else '',
|
|
|
+ 'no_identification': line['@NoIdentificacion'] if '@NoIdentificacion' in line else '',
|
|
|
+ 'quantity': float(line['@Cantidad']),
|
|
|
+ 'uom_code': line['@ClaveUnidad'] if '@ClaveUnidad' in line else '',
|
|
|
+ 'uom': line['@Unidad'] if '@Unidad' in line else '',
|
|
|
+ 'description': line['@Descripcion'],
|
|
|
+ 'discount': float(line['@Descuento']) if '@Descuento' in line else 0,
|
|
|
+ 'unit_price': float(line['@ValorUnitario']),
|
|
|
+ 'uom_id': unidad_id,
|
|
|
+ 'unspsc_product_category_id': product_category_id,
|
|
|
+ 'amount': float(line['@Importe']),
|
|
|
+ }
|
|
|
+ data_line = self.search_cfdi_product(line, cfdi_type, data_line, emitter_partner_id, recipient_partner_id)
|
|
|
+ data_line = self.get_cfdi_tax_lines(data_line, line, cfdi_type, recipient_partner_id)
|
|
|
+ data_list.append(Command.create(data_line))
|
|
|
+ i += 1
|
|
|
+ if data_list:
|
|
|
+ cfdi_data["concept_ids"] = data_list
|
|
|
+ return cfdi_data
|
|
|
+
|
|
|
+ #Obtener intereses de pago
|
|
|
+ def get_payment_tax(self, cfdi_type, xml_data, cfdi_data):
|
|
|
+ if cfdi_type in ['P', 'SP']:
|
|
|
+ payment_tax_list = []
|
|
|
+ payments_list = xml_data['Comprobante']['Complemento']['pago20:Pagos']['pago20:Pago']
|
|
|
+ payments_list = self.get_data_iterable(payments_list)
|
|
|
+ if payments_list:
|
|
|
+ for payment_list in payments_list:
|
|
|
+ payment_date = payment_list["@FechaPago"][:10],
|
|
|
+ payments = payment_list["pago20:DoctoRelacionado"]
|
|
|
+ payments = self.get_data_iterable(payments)
|
|
|
+
|
|
|
+ if payments:
|
|
|
+ for payment in payments:
|
|
|
+ if payment.get("@ObjetoImpDR") and payment.get("@ObjetoImpDR") == '02':
|
|
|
+ payment_taxes = payment["pago20:ImpuestosDR"]["pago20:TrasladosDR"]["pago20:TrasladoDR"]
|
|
|
+ payment_taxes = self.get_data_iterable(payment_taxes)
|
|
|
+ if payment_taxes:
|
|
|
+ for payment_tax in payment_taxes:
|
|
|
+ payment_tax_data = {
|
|
|
+ "name": payment["@IdDocumento"],
|
|
|
+ "serie": payment.get("@Serie"),
|
|
|
+ "folio": payment.get("@Folio"),
|
|
|
+ "currency": payment["@MonedaDR"],
|
|
|
+ "currency_rate": payment["@EquivalenciaDR"],
|
|
|
+ "paid_amount": payment["@ImpPagado"],
|
|
|
+ "previous_balance": payment["@ImpSaldoAnt"],
|
|
|
+ "current_balance": payment["@ImpSaldoInsoluto"],
|
|
|
+ "subject_tax": payment["@ObjetoImpDR"],
|
|
|
+ "payment_date": payment_date[0],
|
|
|
+ "tax_amount": payment_tax.get("@ImporteDR"),
|
|
|
+ "base_amount": payment_tax["@BaseDR"],
|
|
|
+ "type_tax": payment_tax["@ImpuestoDR"],
|
|
|
+ "base_tax": float(payment_tax["@TasaOCuotaDR"]) * 100 if payment_tax.get("@TasaOCuotaDR") else 0,
|
|
|
+ "exempt_tax": True if payment_tax.get("@TipoFactorDR") == 'Exento' else False,
|
|
|
+ }
|
|
|
+ payment_tax_list.append(Command.create(payment_tax_data))
|
|
|
+ if payment_tax_list:
|
|
|
+ cfdi_data["tax_paymnent_ids"] = payment_tax_list
|
|
|
+ return cfdi_data
|
|
|
+
|
|
|
+ def get_addenda_data(self, xml_data):
|
|
|
+ try:
|
|
|
+ addenda = xml_data["Comprobante"]["Addenda"]
|
|
|
+ addenda_header = addenda["customized"]["NEW_ERA"]["Cabecera"]
|
|
|
+ addenda_footer = addenda["customized"]["NEW_ERA"]["DatosPie"]
|
|
|
+ return addenda_header["@DL_VBLEN"], addenda_footer["@SUMQTYEA"]
|
|
|
+ except:
|
|
|
+ return False, False
|
|
|
+
|
|
|
+ #Obtener el producto del cfdi si existe
|
|
|
+ def search_cfdi_product(self, line, cfdi_type, data_line, emitter_partner_id, recipient_partner_id):
|
|
|
+ partner_id = recipient_partner_id if cfdi_type in ["I", "E"] else emitter_partner_id
|
|
|
+ product_tmpl_id = self.env['product.template']
|
|
|
+ concept_id = self.env['account.cfdi.line']
|
|
|
+ account_line_id = self.env['account.move.line']
|
|
|
+ # Buscar el producto para poder relacionarlo a la linea del concepto
|
|
|
+ if '@NoIdentificacion' in line:
|
|
|
+ # Si el comprobante es una factura de proveedor o una nota de cliente del proveedor
|
|
|
+ if cfdi_type in ['SI', 'SE']:
|
|
|
+ # Se busca si es que se cuenta con una lista de precios a proveedor que identifique el producto mediante el codigo del producto
|
|
|
+ product_supplier_id = self.env['product.supplierinfo'].sudo().search([('partner_id', '=', partner_id.id), ('product_code', '=', line['@NoIdentificacion'])], limit=1)
|
|
|
+ if product_supplier_id:
|
|
|
+ product_tmpl_id = product_supplier_id.product_tmpl_id
|
|
|
+ if not product_tmpl_id and cfdi_type in ["I", "E"]:
|
|
|
+ product_tmpl_id = self.env['product.template'].sudo().search([('default_code', '=', line['@NoIdentificacion'])], limit=1)
|
|
|
+ # Identificar si se tiene registro de algun producto que coincida exactamente con la descripción del concepto
|
|
|
+ if not product_tmpl_id and '@Descripcion' in line:
|
|
|
+ if cfdi_type in ['SI', 'SE']:
|
|
|
+ product_supplier_id = self.env['product.supplierinfo'].sudo().search([('partner_id', '=', partner_id.id), ('product_name', '=', line['@Descripcion'])], limit=1)
|
|
|
+ if product_supplier_id:
|
|
|
+ product_tmpl_id = product_supplier_id.product_tmpl_id
|
|
|
+ elif cfdi_type in ['I', 'E']:
|
|
|
+ product_tmpl_id = self.env['product.template'].sudo().search(['|', ("name", "=", line['@Descripcion']), ('default_code', '=', line['@Descripcion'])], limit=1)
|
|
|
+ # Se busca el producto si ya ha habido lineas de producto con el mismo emisor y misma clave de producto o descripcion
|
|
|
+ if not product_tmpl_id and '@ClaveProdServ' in line and partner_id:
|
|
|
+ concept_id = self.env['account.cfdi.line'].sudo().search([("product_tmpl_id", "!=", False), ("emitter_id.id", "=", partner_id.id if cfdi_type in ["SI", "SE"] else emitter_partner_id.id), ("product_code", "=", line['@ClaveProdServ']), ("company_id.id", "=", self.env.company.id)], limit=1)
|
|
|
+ if concept_id:
|
|
|
+ product_tmpl_id = concept_id.product_tmpl_id
|
|
|
+ else:
|
|
|
+ account_line_id = self.env["account.move.line"].sudo().search([("product_id", "!=", False), ("product_id.unspsc_code_id.code", "=", line['@ClaveProdServ']), ("partner_id.id", "=", partner_id.id)], limit=1)
|
|
|
+ if account_line_id:
|
|
|
+ product_tmpl_id = account_line_id.product_id.product_tmpl_id
|
|
|
+ # Identificar si existen lineas de conceptos que coincidan con la misma descripción y del mismo emisor
|
|
|
+ if not product_tmpl_id and '@Descripcion' in line and partner_id:
|
|
|
+ concept_id = self.env['account.cfdi.line'].sudo().search([("product_tmpl_id", "!=", False), ("emitter_id.id", "=", partner_id.id if cfdi_type in ["SI", "SE"] else emitter_partner_id.id), ("description", "=", line['@Descripcion']), ("company_id.id", "=", self.env.company.id)], limit=1)
|
|
|
+ if concept_id:
|
|
|
+ product_tmpl_id = concept_id.product_tmpl_id
|
|
|
+ if not product_tmpl_id and partner_id and partner_id.x_product_tmpl_id:
|
|
|
+ product_tmpl_id = partner_id.x_product_tmpl_id
|
|
|
+
|
|
|
+ if product_tmpl_id:
|
|
|
+ product_id = self.env['product.product'].sudo().search([('product_tmpl_id', '=', product_tmpl_id.id)], limit=1)
|
|
|
+ data_line["product_id"] = product_id.id if product_id else False
|
|
|
+ data_line["product_tmpl_id"] = product_tmpl_id.id
|
|
|
+ categ_id = product_tmpl_id.categ_id
|
|
|
+ if cfdi_type in ["SI", "SE"]:
|
|
|
+ account_id = product_tmpl_id.property_account_expense_id if product_tmpl_id.property_account_expense_id else categ_id.property_account_expense_categ_id if categ_id else False
|
|
|
+ elif cfdi_type in ["I", "E"]:
|
|
|
+ account_id = product_tmpl_id.property_account_income_id if product_tmpl_id.property_account_income_id else categ_id.property_account_income_categ_id if categ_id else False
|
|
|
+ data_line["account_id"] = concept_id.account_id.id if concept_id and concept_id.account_id else account_line_id.account_id.id if account_line_id else account_id.id if account_id else False
|
|
|
+ return data_line
|
|
|
+
|
|
|
+ #Obtener lineas de impuestos
|
|
|
+ def get_cfdi_tax_lines(self, data_line, line, cfdi_type, recipient_partner_id):
|
|
|
+ tax_list = []
|
|
|
+ if 'Impuestos' in line:
|
|
|
+ j = 1
|
|
|
+ if 'Traslados' in line['Impuestos']:
|
|
|
+ if type(line['Impuestos']['Traslados']['Traslado']) is list:
|
|
|
+ impuestos = line['Impuestos']['Traslados']['Traslado']
|
|
|
+ elif type(line['Impuestos']['Traslados']['Traslado']) is OrderedDict:
|
|
|
+ impuestos = line['Impuestos']['Traslados'].items()
|
|
|
+ else:
|
|
|
+ impuestos = [line['Impuestos']['Traslados']['Traslado']]
|
|
|
+ for value_tax in impuestos:
|
|
|
+ if type(line['Impuestos']['Traslados']['Traslado']) is list:
|
|
|
+ impuesto = value_tax
|
|
|
+ elif type(line['Impuestos']['Traslados']['Traslado']) is OrderedDict:
|
|
|
+ impuesto = value_tax[1]
|
|
|
+ else:
|
|
|
+ impuesto = value_tax
|
|
|
+ if str(impuesto['@TipoFactor']).strip().upper() == 'EXENTO':
|
|
|
+ tasa_o_cuota = 0
|
|
|
+ importe = 0
|
|
|
+ else:
|
|
|
+ tasa_o_cuota = float(impuesto['@TasaOCuota'])
|
|
|
+ importe = float(impuesto['@Importe'])
|
|
|
+ tax_data = {
|
|
|
+ 'sequence': j,
|
|
|
+ 'base': float(impuesto['@Base']),
|
|
|
+ 'code': impuesto['@Impuesto'],
|
|
|
+ 'factor_type': impuesto['@TipoFactor'],
|
|
|
+ 'rate': tasa_o_cuota,
|
|
|
+ 'amount': importe,
|
|
|
+ 'tax_type': 'traslado'
|
|
|
+ }
|
|
|
+ j = j + 1
|
|
|
+ amount = tasa_o_cuota * 100
|
|
|
+ tax_domain = [('amount', '=', amount), ('company_id', '=', self.env.company.id)]
|
|
|
+ t_id = self.env["account.tax"]
|
|
|
+ if tax_data.get("impuesto") == '002':
|
|
|
+ tax_domain.append(("name", "ilike", "iva"))
|
|
|
+ elif tax_data.get("impuesto") == '003':
|
|
|
+ tax_domain.append(("name", "ilike", "ieps"))
|
|
|
+ elif tax_data.get("impuesto") == '001':
|
|
|
+ tax_domain.append(("name", "ilike", "isr"))
|
|
|
+
|
|
|
+ if cfdi_type in ['I', 'E']:
|
|
|
+ tax_domain.append(('type_tax_use', '=', 'sale'))
|
|
|
+ t_id = self.env['account.tax'].sudo().search(tax_domain, limit=1)
|
|
|
+ elif cfdi_type in ['SI', 'SE']:
|
|
|
+ tax_domain.append(('type_tax_use', '=', 'purchase'))
|
|
|
+ t_id = self.env['account.tax'].sudo().search(tax_domain, limit=1)
|
|
|
+ if t_id:
|
|
|
+ tax_data["tax_id"] = t_id.id
|
|
|
+ tax_list.append(Command.create(tax_data))
|
|
|
+
|
|
|
+ if 'Retenciones' in line['Impuestos']:
|
|
|
+ if type(line['Impuestos']['Retenciones']['Retencion']) is list:
|
|
|
+ retenciones = line['Impuestos']['Retenciones']['Retencion']
|
|
|
+ elif type(line['Impuestos']['Retenciones']['Retencion']) is OrderedDict:
|
|
|
+ retenciones = line['Impuestos']['Retenciones'].items()
|
|
|
+ else:
|
|
|
+ retenciones = [line['Impuestos']['Retenciones']['Retencion']]
|
|
|
+ for value_tax in retenciones:
|
|
|
+ if type(line['Impuestos']['Retenciones']['Retencion']) is list:
|
|
|
+ retencion = value_tax
|
|
|
+ elif type(line['Impuestos']['Retenciones']['Retencion']) is OrderedDict:
|
|
|
+ retencion = value_tax[1]
|
|
|
+ else:
|
|
|
+ retencion = value_tax
|
|
|
+ tasa_o_cuota = float(retencion['@TasaOCuota'])
|
|
|
+ importe = float(retencion['@Importe'])
|
|
|
+ tax_data = {
|
|
|
+ 'sequence': j,
|
|
|
+ 'base': float(retencion['@Base']),
|
|
|
+ 'code': retencion['@Impuesto'],
|
|
|
+ 'factor_type': retencion['@TipoFactor'],
|
|
|
+ 'rate': tasa_o_cuota,
|
|
|
+ 'amount': importe,
|
|
|
+ 'tax_type': 'retencion'
|
|
|
+ }
|
|
|
+ j = j + 1
|
|
|
+
|
|
|
+ amount = round(-(tasa_o_cuota * 100), 2)
|
|
|
+ tax_domain = [('amount', '=', amount), ('company_id', '=', self.env.company.id)]
|
|
|
+ t_id = self.env['account.tax']
|
|
|
+ if tax_data.get("impuesto") == '002':
|
|
|
+ tax_domain.append(("name", "ilike", "iva"))
|
|
|
+ elif tax_data.get("impuesto") == '003':
|
|
|
+ tax_domain.append(("name", "ilike", "ieps"))
|
|
|
+ elif tax_data.get("impuesto") == '001':
|
|
|
+ tax_domain.append(("name", "ilike", "isr"))
|
|
|
+ if cfdi_type in ['I', 'E']:
|
|
|
+ tax_domain.append(('type_tax_use', '=', 'sale'))
|
|
|
+ t_id = self.env['account.tax'].sudo().search(tax_domain, limit=1)
|
|
|
+ elif cfdi_type in ['SI', 'SE']:
|
|
|
+ tax_domain.append(('type_tax_use', '=', 'purchase'))
|
|
|
+ t_id = self.env['account.tax'].sudo().search(tax_domain, limit=1)
|
|
|
+ if t_id:
|
|
|
+ tax_data["tax_id"] = t_id.id
|
|
|
+
|
|
|
+ if not t_id and cfdi_type in ['SI', 'SE']:
|
|
|
+ if tax_data.get("impuesto") == '001':
|
|
|
+ if recipient_partner_id.tax_isr_id:
|
|
|
+ tax_data["tax_id"] = recipient_partner_id.tax_isr_id.id
|
|
|
+ elif tax_data.get("impuesto") == '002':
|
|
|
+ if recipient_partner_id.tax_iva_id:
|
|
|
+ tax_data["tax_id"] = recipient_partner_id.tax_iva_id.id
|
|
|
+ tax_list.append(Command.create(tax_data))
|
|
|
+ if tax_list:
|
|
|
+ data_line["tax_ids"] = tax_list
|
|
|
+ return data_line
|
|
|
+
|
|
|
+ # Obteniendo el diario contable dependiendo del tipo de comprobante
|
|
|
+ def get_cfdi_journal_id(self, cfdi_type, emitter_partner_id, recipient_partner_id):
|
|
|
+ journal_id = self.env['account.journal'].sudo().search([('x_cfdi_type', '=', cfdi_type), ("company_id.id", "=", self.env.company.id)], limit=1)
|
|
|
+ # Buscamos si ya hubo un CFDI al mismo cliente y receptor y del mismo tipo y que tenga un diario colocado
|
|
|
+ if not journal_id:
|
|
|
+ cfdi_id = self.env["account.cfdi"].sudo().search(
|
|
|
+ [("emitter_id.id", "=", emitter_partner_id.id),
|
|
|
+ ("receiver_id.id", "=", recipient_partner_id.id), ("cfdi_type", "=", cfdi_type),
|
|
|
+ ("journal_id", "!=", False)], limit=1)
|
|
|
+ journal_id = cfdi_id.journal_id if cfdi_id else False
|
|
|
+ account_id = journal_id.default_account_id if journal_id and journal_id.default_account_id else False
|
|
|
+ if not account_id:
|
|
|
+ partner_id = recipient_partner_id if cfdi_type in ["I", "E"] else emitter_partner_id
|
|
|
+ account_id = self.get_expense_cfdi_account_id(cfdi_type, partner_id)
|
|
|
+ return journal_id, account_id
|
|
|
+
|
|
|
+ # Obtener la cuenta de gastos
|
|
|
+ def get_expense_cfdi_account_id(self, cfdi_type, partner_id):
|
|
|
+ if partner_id:
|
|
|
+ expense_account_id = partner_id.x_account_expense_id
|
|
|
+ # Buscamos un CFDI parecido para obtener la cuenta por pagar
|
|
|
+ if not expense_account_id and cfdi_type in ['I', 'E']:
|
|
|
+ cfdi_id = self.env["account.cfdi"].sudo().search(
|
|
|
+ [("receiver_id.id", "=", partner_id.id), ("cfdi_type", "=", cfdi_type),
|
|
|
+ ("account_id", "!=", False)], limit=1)
|
|
|
+ expense_account_id = cfdi_id.payable_account_id if cfdi_id else False
|
|
|
+ elif not expense_account_id and cfdi_type in ['SI', 'SE']:
|
|
|
+ cfdi_id = self.env["account.cfdi"].sudo().search(
|
|
|
+ [("emitter_id.id", "=", partner_id.id), ("cfdi_type", "=", cfdi_type),
|
|
|
+ ("account_id", "!=", False)], limit=1)
|
|
|
+ expense_account_id = cfdi_id.payable_account_id if cfdi_id else False
|
|
|
+ return expense_account_id
|
|
|
+
|
|
|
+ # Obtener cuenta por pagar dependiendo del tipo de comprobante
|
|
|
+ def get_payable_cfdi_account_id(self, cfdi_type, partner_id):
|
|
|
+ # Se busca si se tiene configurado la cuenta por pagar en la cuenta sino se busca por el contacto y por ultimo se busca un cfdi con el mismo contacto y tipo
|
|
|
+ payable_account_id = self.env['account.account'].sudo().search([('x_cfdi_type', '=', cfdi_type), ("company_ids.id", "=", self.env.company.id)], limit=1)
|
|
|
+ if not payable_account_id and partner_id:
|
|
|
+ payable_account_id = partner_id.property_account_payable_id
|
|
|
+ # Buscamos un CFDI parecido para obtener la cuenta por pagar
|
|
|
+ if not payable_account_id and cfdi_type in ['I', 'E']:
|
|
|
+ cfdi_id = self.env["account.cfdi"].sudo().search(
|
|
|
+ [("receiver_id.id", "=", partner_id.id), ("cfdi_type", "=", cfdi_type),
|
|
|
+ ("payable_account_id", "!=", False)], limit=1)
|
|
|
+ payable_account_id = cfdi_id.payable_account_id if cfdi_id else False
|
|
|
+ elif not payable_account_id and cfdi_type in ['SI', 'SE']:
|
|
|
+ cfdi_id = self.env["account.cfdi"].sudo().search(
|
|
|
+ [("emitter_id.id", "=", partner_id.id), ("cfdi_type", "=", cfdi_type),
|
|
|
+ ("payable_account_id", "!=", False)], limit=1)
|
|
|
+ payable_account_id = cfdi_id.payable_account_id if cfdi_id else False
|
|
|
+ return payable_account_id
|
|
|
+
|
|
|
+ # Obtener el emisor y receptor del cfdi
|
|
|
+ def get_cfdi_partners(self, xml_data):
|
|
|
+ emitter_id = self.env['res.partner'].sudo().search([('vat', '=', xml_data['Comprobante']['Emisor']['@Rfc'])], limit=1)
|
|
|
+ receiver_id = self.env['res.partner'].sudo().search([('vat', '=', xml_data['Comprobante']['Receptor']['@Rfc'])], limit=1)
|
|
|
+ if not emitter_id:
|
|
|
+ emitter_id = self.create_cfdi_partner(xml_data, "Emisor")
|
|
|
+ if not receiver_id:
|
|
|
+ receiver_id = self.create_cfdi_partner(xml_data, "Receptor")
|
|
|
+ return emitter_id, receiver_id
|
|
|
+
|
|
|
+ # Crear los contactos del CFDI si es necesario
|
|
|
+ def create_cfdi_partner(self, xml_data, partner_type):
|
|
|
+ data = {
|
|
|
+ 'name': xml_data['Comprobante'][partner_type]['@Nombre'],
|
|
|
+ 'vat': xml_data['Comprobante'][partner_type]['@Rfc'],
|
|
|
+ 'l10n_mx_edi_fiscal_regime': xml_data['Comprobante'][partner_type][
|
|
|
+ '@RegimenFiscal'] if partner_type == "Emisor" else xml_data['Comprobante'][partner_type][
|
|
|
+ '@RegimenFiscalReceptor'],
|
|
|
+ 'country_id': self.env.company.country_id.id,
|
|
|
+ 'company_type': 'company'
|
|
|
+ }
|
|
|
+ partner_id = self.env["res.partner"].create(data)
|
|
|
+ return partner_id
|
|
|
+
|
|
|
+ # --------------------------------------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+
|
|
|
+ # ---------------------------------------------------Metodos de descarga masiva---------------------------------------------------------
|
|
|
+
|
|
|
+ def download_massive_pdf_zip(self):
|
|
|
+ return self.download_massive_zip("PDF Masivos.zip", "pdf_id")
|
|
|
+
|
|
|
+ def download_massive_xml_zip(self):
|
|
|
+ return self.download_massive_zip("XML Masivos.zip", "attachment_id")
|
|
|
+
|
|
|
+ def download_massive_zip(self, filename, field_name):
|
|
|
+ self = self.with_user(1)
|
|
|
+ zip_file = self.env['ir.attachment'].sudo().search([('name', '=', filename)], limit=1)
|
|
|
+ if zip_file:
|
|
|
+ zip_file.sudo().unlink()
|
|
|
+
|
|
|
+ # Funcion para decodificar el archivo
|
|
|
+ def isBase64_decodestring(s):
|
|
|
+ try:
|
|
|
+ decode_archive = base64.decodebytes(s)
|
|
|
+ return decode_archive
|
|
|
+ except Exception as e:
|
|
|
+ raise ValidationError('Error:', + str(e))
|
|
|
+
|
|
|
+ tempdir_file = TemporaryDirectory()
|
|
|
+ location_tempdir = tempdir_file.name
|
|
|
+ # Creando ruta dinamica para poder guardar el archivo zip
|
|
|
+ date_act = date.today()
|
|
|
+ file_name = 'DescargaMasiva(Fecha de descarga' + " - " + str(date_act) + ")"
|
|
|
+ file_name_zip = file_name + ".zip"
|
|
|
+ zipfilepath = os.path.join(location_tempdir, file_name_zip)
|
|
|
+ path_files = os.path.join(location_tempdir)
|
|
|
+
|
|
|
+ # Creando zip
|
|
|
+ for file in self.mapped(field_name):
|
|
|
+ object_name = file.name
|
|
|
+ ruta_ob = object_name
|
|
|
+ object_handle = open(os.path.join(location_tempdir, ruta_ob), "wb")
|
|
|
+ object_handle.write(isBase64_decodestring(file.datas))
|
|
|
+ object_handle.close()
|
|
|
+
|
|
|
+ with ZipFile(zipfilepath, 'w') as zip_obj:
|
|
|
+ for file in os.listdir(path_files):
|
|
|
+ file_path = os.path.join(path_files, file)
|
|
|
+ if file_path != zipfilepath:
|
|
|
+ zip_obj.write(file_path, basename(file_path))
|
|
|
+
|
|
|
+ with open(zipfilepath, 'rb') as file_data:
|
|
|
+ bytes_content = file_data.read()
|
|
|
+ encoded = base64.b64encode(bytes_content)
|
|
|
+
|
|
|
+ data = {
|
|
|
+ 'name': filename,
|
|
|
+ 'type': 'binary',
|
|
|
+ 'datas': encoded,
|
|
|
+ 'company_id': self.env.company.id
|
|
|
+ }
|
|
|
+ attachment = self.env['ir.attachment'].sudo().create(data)
|
|
|
+ return self.download_zip(file_name_zip, attachment.id)
|
|
|
+
|
|
|
+ def download_zip(self, filename, id_file):
|
|
|
+ path = "/web/binary/download_document?"
|
|
|
+ model = "ir.attachment"
|
|
|
+
|
|
|
+ url = path + "model={}&id={}&filename={}".format(model, id_file, filename)
|
|
|
+ return {
|
|
|
+ 'type': 'ir.actions.act_url',
|
|
|
+ 'url': url,
|
|
|
+ 'target': 'self',
|
|
|
+ }
|
|
|
+
|
|
|
+ # ---------------------------------------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+ # ---------------------------------------------------Metodos de conciliación---------------------------------------------------------
|
|
|
+
|
|
|
+ def action_done(self):
|
|
|
+ self = self.with_user(1)
|
|
|
+ invoice_list = []
|
|
|
+ folio_names = []
|
|
|
+ for rec in self.filtered(lambda cfdi: not cfdi.move_id and cfdi.attachment_id and cfdi.cfdi_type in ["SI", "I","SE"]):
|
|
|
+ cfdi_type = rec.cfdi_type
|
|
|
+ partner_id = rec.emitter_id if cfdi_type in ["SI",'SE','SP'] else rec.receiver_id
|
|
|
+ folio = f"{rec.serie}-{rec.folio}" if rec.serie and rec.folio else f"{rec.serie}" if rec.serie and not rec.folio else f"{rec.folio}" if not rec.serie and rec.folio else ''
|
|
|
+ move_type = {
|
|
|
+ "SI": "in_invoice",
|
|
|
+ "I": "out_invoice",
|
|
|
+ "SE": "in_refund",
|
|
|
+ "E": "out_refund",
|
|
|
+ }
|
|
|
+ invoice_data = {
|
|
|
+ 'move_type': move_type.get(cfdi_type),
|
|
|
+ 'partner_id': partner_id.id,
|
|
|
+ 'date': rec.date,
|
|
|
+ 'invoice_date': rec.date,
|
|
|
+ 'invoice_date_due': rec.date,
|
|
|
+ 'fiscal_position_id': partner_id.property_account_position_id.id if partner_id.property_account_position_id else rec.fiscal_position_id.id,
|
|
|
+ 'ref': folio,
|
|
|
+ 'amount_total_signed': rec.total,
|
|
|
+ 'amount_total': rec.total,
|
|
|
+ 'journal_id': rec.journal_id.id,
|
|
|
+ 'company_id': rec.company_id.id,
|
|
|
+ 'cfdi_id': rec.id,
|
|
|
+ 'x_uuid': rec.uuid,
|
|
|
+ "x_delivery_number": rec.delivery_number,
|
|
|
+ "x_invoice_qty": rec.invoice_qty
|
|
|
+ }
|
|
|
+ if folio != '' and not self.env["account.move"].sudo().search([("name", "=", folio), ("state", "=", "posted")], limit=1) and folio not in folio_names and cfdi_type == "I":
|
|
|
+ invoice_data["name"] = folio
|
|
|
+ folio_names.append(folio)
|
|
|
+ i = 1
|
|
|
+ line_list = []
|
|
|
+ for line in rec.concept_ids:
|
|
|
+ if float(line.amount) > 0:
|
|
|
+ data_line = {
|
|
|
+ 'sequence': i,
|
|
|
+ 'name': line.description,
|
|
|
+ 'quantity': float(line.quantity),
|
|
|
+ 'product_uom_id': line.uom_id.id,
|
|
|
+ 'discount': (float(line.discount) * 100) / float(line.amount),
|
|
|
+ 'price_unit': float(line.unit_price),
|
|
|
+ 'tax_ids': line.mapped("tax_ids.tax_id").ids,
|
|
|
+ 'account_id': line.account_id.id if line.account_id else rec.account_id.id if rec.account_id else False,
|
|
|
+ 'analytic_distribution': line.analytic_distribution if line.analytic_distribution else rec.analytic_distribution,
|
|
|
+ 'partner_id': partner_id.id,
|
|
|
+ }
|
|
|
+
|
|
|
+ if line.product_tmpl_id:
|
|
|
+ product_id = self.env['product.product'].sudo().search([('product_tmpl_id', '=', line.product_tmpl_id.id)], limit=1)
|
|
|
+ data_line["product_id"] = product_id.id
|
|
|
+ line_list.append(Command.create(data_line))
|
|
|
+ i = i + 1
|
|
|
+ invoice_data["invoice_line_ids"] = line_list
|
|
|
+ invoice_list.append(invoice_data)
|
|
|
+ invoice_ids = self.env['account.move'].with_context(check_move_validity=False).sudo().create(invoice_list)
|
|
|
+
|
|
|
+ for invoice_id in invoice_ids:
|
|
|
+ attachment_id = invoice_id.cfdi_id.attachment_id
|
|
|
+ invoice_id.cfdi_id.write({
|
|
|
+ "move_id": invoice_id.id,
|
|
|
+ "state": "done"
|
|
|
+ })
|
|
|
+ attachment_id.write({
|
|
|
+ 'res_model': 'account.move',
|
|
|
+ 'res_id': invoice_id.id,
|
|
|
+ })
|
|
|
+ if invoice_id.move_type == "out_invoice":
|
|
|
+ if attachment_id:
|
|
|
+ id_edi_format = self.env['account.edi.format'].sudo().search([('name', '=', 'CFDI (4.0)')], limit=1)
|
|
|
+ if not invoice_id.edi_document_ids:
|
|
|
+ if id_edi_format:
|
|
|
+ create_edi = self.env['account.edi.document'].sudo().create(
|
|
|
+ {'edi_format_id': id_edi_format.id, 'attachment_id': attachment_id.id, 'state': 'sent',
|
|
|
+ 'move_id': invoice_id.id, 'error': False})
|
|
|
+ invoice_id.write({'edi_document_ids': [(6, False, [create_edi.id])], 'l10n_mx_edi_cfdi_uuid': invoice_id.l10n_mx_edi_cfdi_uuid_cusom})
|
|
|
+ # Se colocaria la factura como timbrada
|
|
|
+ elif id_edi_format and invoice_id.edi_document_ids:
|
|
|
+ edi_format_id = invoice_id.edi_document_ids.filtered(
|
|
|
+ lambda edi: edi.edi_format_id.id == id_edi_format.id)
|
|
|
+ if edi_format_id:
|
|
|
+ edi_format_id["attachment_id"] = attachment_id.id
|
|
|
+ edi_format_id["error"] = False
|
|
|
+ edi_format_id["state"] = "sent"
|
|
|
+ else:
|
|
|
+ data = {
|
|
|
+ 'move_id': invoice_id.id,
|
|
|
+ 'attachment_id': attachment_id.id,
|
|
|
+ 'state': 'sent',
|
|
|
+ 'error': False,
|
|
|
+ 'edi_format_id': id_edi_format.id
|
|
|
+ }
|
|
|
+ self.env["account.edi.document"].sudo().create([data])
|
|
|
+ invoice_id.write({'l10n_mx_edi_cfdi_uuid': invoice_id.l10n_mx_edi_cfdi_uuid_cusom})
|
|
|
+
|
|
|
+ invoice_id.write({
|
|
|
+ "state": "posted"
|
|
|
+ })
|
|
|
+ return {
|
|
|
+ "name": _("Facturas"),
|
|
|
+ "view_mode": "list,form",
|
|
|
+ "res_model": "account.move",
|
|
|
+ "type": "ir.actions.act_window",
|
|
|
+ "target": "current",
|
|
|
+ "domain": [('id', 'in', invoice_ids.ids)]
|
|
|
+ }
|
|
|
+
|
|
|
+ def action_unlink_move(self):
|
|
|
+ for rec in self:
|
|
|
+ if rec.move_id:
|
|
|
+ rec.attachment_id.write({
|
|
|
+ 'res_model': 'account.cfdi',
|
|
|
+ 'res_id': rec.id,
|
|
|
+ })
|
|
|
+ rec.write({
|
|
|
+ "state": "draft",
|
|
|
+ "move_id": False
|
|
|
+ })
|
|
|
+ rec.move_id.write({
|
|
|
+ 'cfdi_id': False,
|
|
|
+ 'x_uuid': False
|
|
|
+ })
|
erickabrego